Changeset 3503:f0bed8abcd9c in orange


Ignore:
Timestamp:
04/06/07 09:20:36 (7 years ago)
Author:
Gregor <Gregor@…>
Branch:
default
Convert:
144ab4788027253d32682c727ca408026aae26d3
Message:
  • bugFix. A QColor was not hashable on some machines
Location:
orange/OrangeWidgets
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/OWDlgs.py

    r3485 r3503  
    55from qtcanvas import QCanvas 
    66from ColorPalette import * 
    7          
     7 
    88class OWChooseImageSizeDlg(OWBaseWidget): 
    99    settingsList = ["selectedSize", "customX", "customY", "lastSaveDirName", "penWidthFactor"] 
     
    2020 
    2121        self.loadSettings() 
    22          
     22 
    2323        self.space = OWGUI.widgetBox(self) 
    2424        self.layout = QVBoxLayout(self, 8) 
    2525        self.layout.addWidget(self.space) 
    26          
     26 
    2727        box = QVButtonGroup("Image Size", self.space) 
    2828        if isinstance(graph, QwtPlot): 
    2929            size = OWGUI.radioButtonsInBox(box, self, "selectedSize", ["Current size", "400 x 400", "600 x 600", "800 x 800", "Custom:"], callback = self.updateGUI) 
    30              
     30 
    3131            ind1 = OWGUI.indentedBox(box) 
    3232            ind2 = OWGUI.indentedBox(box) 
     
    3838        elif isinstance(graph, QCanvas): 
    3939            OWGUI.widgetLabel(box, "Image size will be set automatically.") 
    40              
     40 
    4141        self.printButton =          OWGUI.button(self.space, self, "Print", callback = self.printPic) 
    4242        self.saveImageButton =      OWGUI.button(self.space, self, "Save Image", callback = self.saveImage) 
     
    4646            self.connect(butt, SIGNAL("clicked()"), self.accept)        # also connect the button to accept so that we close the dialog 
    4747        OWGUI.button(self.space, self, "Cancel", callback = self.reject) 
    48                                         
     48 
    4949        self.resize(200,270) 
    5050        self.updateGUI() 
     
    5555            filename = self.getFileName("graph.png", "Portable Network Graphics (*.PNG);;Windows Bitmap (*.BMP);;Graphics Interchange Format (*.GIF)", ".png") 
    5656            if not filename: return 
    57          
     57 
    5858        (fil,ext) = os.path.splitext(filename) 
    5959        ext = ext[1:].upper() 
    60         if ext == "" or ext not in ("BMP", "GIF", "PNG") :   
     60        if ext == "" or ext not in ("BMP", "GIF", "PNG") : 
    6161            ext = "PNG"     # if no format was specified, we choose png 
    6262            filename = filename + ".png" 
     
    6464        if not size: 
    6565            size = self.getSize() 
    66              
     66 
    6767        painter = QPainter() 
    6868        if size.isEmpty(): buffer = QPixmap(self.graph.size()) # any size can do, now using the window size 
     
    7777        if closeDialog: 
    7878            QDialog.accept(self) 
    79          
     79 
    8080    def saveToMatplotlib(self): 
    8181        filename = self.getFileName("graph.py","Python Script (*.py)", ".py") 
     
    8787                f = open(filename, "wt") 
    8888                f.write("from pylab import *\nfrom matplotlib.patches import Rectangle\n\n#constants\nx1 = %f; x2 = %f\ny1 = 0.0; y2 = %f\ndpi = 80\nxsize = %d\nysize = %d\nedgeOffset = 0.01\n\nfigure(facecolor = 'w', figsize = (xsize/float(dpi), ysize/float(dpi)), dpi = dpi)\na = gca()\nhold(True)\n" % (minx, maxx, maxy, maxx-minx, maxy-miny)) 
    89                  
     89 
    9090                sortedList = [(item.z(), item) for item in self.graph.allItems()] 
    9191                sortedList.sort()   # sort items by z value 
    92                  
     92 
    9393                for (z, item) in sortedList: 
    9494                    if not item.visible(): continue 
     
    9797                        brushc = self._getColorFromObject(item.brush()) 
    9898                        penWidth = item.pen().width() 
    99                          
     99 
    100100                        if   isinstance(item, QCanvasEllipse): continue 
    101101                        elif isinstance(item, QCanvasPolygon): continue 
     
    143143                minx,maxx,miny,maxy = self.getQCanvasBoundaries() 
    144144                factor = min(float(width)/(maxx-minx), float(height)/(maxy-miny)) 
    145              
     145 
    146146            if height == 0: 
    147147                print "Error. Height is zero. Preventing division by zero." 
     
    151151            if pageKvoc < sizeKvoc:     rect = QRect(printer.margins().width(), printer.margins().height(), width, height) 
    152152            else:                       rect = QRect(printer.margins().width(), printer.margins().height(), width, height) 
    153              
     153 
    154154            self.fillPainter(painter, rect, factor) 
    155155            painter.end() 
     
    217217        return minx-10, maxx+10, miny-10, maxy+10 
    218218 
    219          
    220     def getFileName(self, defaultName, mask, extension):         
     219 
     220    def getFileName(self, defaultName, mask, extension): 
    221221        fileName = str(QFileDialog.getSaveFileName(self.lastSaveDirName + defaultName, mask, None, "Save to..", "Save to..")) 
    222222        if not fileName: return None 
     
    241241 
    242242    def updateGUI(self): 
    243         if isinstance(self.graph, QwtPlot):         
     243        if isinstance(self.graph, QwtPlot): 
    244244            self.customXEdit.setEnabled(self.selectedSize == 4) 
    245245            self.customYEdit.setEnabled(self.selectedSize == 4) 
     
    252252        return col 
    253253 
    254        
     254 
    255255 
    256256class ColorPalette(OWBaseWidget): 
     
    271271        self.mainArea.setSpacing(4) 
    272272        self.schemaCombo = OWGUI.comboBox(self.mainArea, self, "selectedSchemaIndex", box = "Saved Profiles", callback = self.paletteSelected) 
    273              
     273 
    274274        self.hbox = OWGUI.widgetBox(self, orientation = "horizontal") 
    275275        self.layout.addWidget(self.hbox) 
    276          
     276 
    277277        self.okButton = OWGUI.button(self.hbox, self, "OK", self.acceptChanges) 
    278278        self.cancelButton = OWGUI.button(self.hbox, self, "Cancel", self.reject) 
     
    298298                self.colorSchemas[self.selectedSchemaIndex] = [self.colorSchemas[self.selectedSchemaIndex][0], state] 
    299299                QDialog.accept(self) 
    300      
     300 
    301301    def createBox(self, boxName, boxCaption = None): 
    302302        box = OWGUI.widgetBox(self.mainArea, boxCaption) 
     
    316316        self.__dict__[buttonName].setSizePolicy(QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed )) 
    317317        self.__dict__["buttonLabel"+str(self.counter)].setSizePolicy(QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed )) 
    318          
     318 
    319319        self.counter += 1 
    320          
     320 
    321321 
    322322    def createContinuousPalette(self, paletteName, boxCaption, passThroughBlack = 0, initialColor1 = Qt.white, initialColor2 = Qt.black): 
     
    333333        self.__dict__[paletteName+"Right"].setColor(initialColor2) 
    334334        self.__dict__["buttonBox"+str(self.counter)].addSpace(6) 
    335          
     335 
    336336        self.__dict__[paletteName+"passThroughBlack"] = passThroughBlack 
    337337        self.__dict__[paletteName+"passThroughBlackCheckbox"] = OWGUI.checkBox(self.__dict__["buttonBox"+str(self.counter)], self, paletteName+"passThroughBlack", "Pass through black", callback = self.colorSchemaChange) 
     
    345345        box = OWGUI.widgetBox(self.mainArea, boxCaption) 
    346346        hbox = OWGUI.widgetBox(box, orientation = 'horizontal') 
    347          
     347 
    348348        self.discListbox = QListBox(hbox) 
    349349 
     
    370370        for ind in range(len(self.discreteColors)): 
    371371            self.discListbox.insertItem(OWTools.ColorPixmap(self.discreteColors[ind], 15), "Color %d" % (ind)) 
    372          
     372 
    373373    def changeDiscreteColor(self, item): 
    374374        ind = self.discListbox.index(item) 
     
    383383        for ind in range(len(self.discreteColors)): 
    384384            self.discListbox.insertItem(OWTools.ColorPixmap(self.discreteColors[ind], 15), "Color %d" % (ind)) 
    385              
     385 
    386386    def loadCBPalette(self): 
    387387        self.discListbox.clear() 
     
    389389        for ind in range(len(self.discreteColors)): 
    390390            self.discListbox.insertItem(OWTools.ColorPixmap(self.discreteColors[ind], 15), "Color %d" % (ind)) 
    391              
     391 
    392392    def showPopup(self): 
    393393        point = self.buttLoad.mapToGlobal(QPoint(0, self.buttLoad.height())) 
     
    406406                self.discListbox.setSelected(i-1, TRUE) 
    407407                self.discreteColors.insert(i-1, self.discreteColors.pop(i)) 
    408          
    409  
    410     # move selected attribute in "Attribute Order" list one place down   
     408 
     409 
     410    # move selected attribute in "Attribute Order" list one place down 
    411411    def moveAttrDOWN(self): 
    412412        count = self.discListbox.count() 
     
    421421                self.discListbox.setSelected(i+1, TRUE) 
    422422                self.discreteColors.insert(i+1, self.discreteColors.pop(i)) 
    423                  
     423 
    424424 
    425425    # ##################################################### 
    426          
     426 
    427427    def getCurrentSchemeIndex(self): 
    428428        return self.selectedSchemaIndex 
     
    449449        return [l1, l2, l3] 
    450450 
    451      
     451 
    452452    def setColorSchemas(self, schemas = None, selectedSchemaIndex = 0): 
    453453        self.schemaCombo.clear() 
     
    463463        self.selectedSchemaIndex = selectedSchemaIndex 
    464464        self.paletteSelected() 
    465          
     465 
    466466    def setCurrentState(self, state): 
    467467        [buttons, contPalettes, discPalette] = state 
     
    481481            for ind in range(len(self.discreteColors)): 
    482482                self.discListbox.insertItem(OWTools.ColorPixmap(self.discreteColors[ind], 15), "Color %d" % (ind)) 
    483          
     483 
    484484    def paletteSelected(self): 
    485         if not self.schemaCombo.count(): return  
     485        if not self.schemaCombo.count(): return 
    486486 
    487487        # if we selected "Save current palette as..." option then add another option to the list 
    488         if self.selectedSchemaIndex == self.schemaCombo.count()-1:     
     488        if self.selectedSchemaIndex == self.schemaCombo.count()-1: 
    489489            message = "Please enter a new name for the current color schema:" 
    490490            ok = FALSE 
     
    501501                        index = oldNames.index(newName.lower()) 
    502502                        self.colorSchemas.pop(index) 
    503                          
     503 
    504504                    if (ok): 
    505505                        self.colorSchemas.insert(0, (newName, self.getCurrentState())) 
     
    510510                    state = self.getCurrentState()  # if we pressed cancel we have to select a different item than the "Save current palette as..." 
    511511                    self.selectedSchemaIndex = 0    # this will change the color buttons, so we have to restore the colors 
    512                     self.setCurrentState(state)              
     512                    self.setCurrentState(state) 
    513513        else: 
    514514            schema = self.colorSchemas[self.selectedSchemaIndex][1] 
    515515            self.setCurrentState(schema) 
    516516            if self.callback: self.callback() 
    517              
     517 
    518518 
    519519    def rgbToQColor(self, rgb): 
     
    539539class ContinuousPaletteGenerator: 
    540540    def __init__(self, color1, color2, passThroughBlack): 
    541         self.color1 = color1 
    542         self.color2 = color2 
     541        self.c1Red, self.c1Green, self.c1Blue = color1.red(), color1.green(), color1.blue() 
     542        self.c2Red, self.c2Green, self.c2Blue = color2.red(), color2.green(), color2.blue() 
    543543        self.passThroughBlack = passThroughBlack 
     544 
     545    def getRGB(self, val): 
     546        if self.passThroughBlack: 
     547            if val < 0.5: 
     548                return (self.c1Red - self.c1Red*val*2, self.c1Green - self.c1Green*val*2, self.c1Blue - self.c1Blue*val*2) 
     549            else: 
     550                return (self.c2Red*(val-0.5)*2., self.c2Green*(val-0.5)*2., self.c2Blue*(val-0.5)*2.) 
     551        else: 
     552            return (self.c1Red + (self.c2Red-self.c1Red)*val, self.c1Green + (self.c2Green-self.c1Green)*val, self.c1Blue + (self.c2Blue-self.c1Blue)*val) 
    544553 
    545554    # val must be between 0 and 1 
    546555    def __getitem__(self, val): 
    547         if self.passThroughBlack: 
    548             if val < 0.5: 
    549                 return QColor(self.color1.red() - self.color1.red()*val*2, self.color1.green() - self.color1.green()*val*2, self.color1.blue() - self.color1.blue()*val*2) 
    550             else: 
    551                 return QColor(self.color2.red()*(val-0.5)*2., self.color2.green()*(val-0.5)*2., self.color2.blue()*(val-0.5)*2.) 
    552         else: 
    553             return QColor(self.color1.red() + (self.color2.red()-self.color1.red())*val, self.color1.green() + (self.color2.green()-self.color1.green())*val, self.color1.blue() + (self.color2.blue()-self.color1.blue())*val) 
    554          
     556        return QColor(*self.getRGB(val)) 
     557 
    555558 
    556559if __name__== "__main__": 
    557560    a = QApplication(sys.argv) 
    558      
     561 
    559562##    c = ColorPalette(None, modal = FALSE) 
    560563##    c.createContinuousPalette("continuousPalette", "Continuous Palette") 
     
    572575##    c.show() 
    573576##    a.exec_loop() 
    574      
     577 
    575578    c = OWChooseImageSizeDlg(None) 
    576579    a.setMainWidget(c) 
    577580    c.show() 
    578581    a.exec_loop() 
    579      
  • orange/OrangeWidgets/Visualize/OWLinProjGraph.py

    r3483 r3503  
    260260                if not validData[i]: continue 
    261261                if hasDiscreteClass and self.useDifferentColors: 
    262                     newColor = self.discPalette[classValueIndices[self.rawdata[i].getclass().value]] 
     262                    newColor = self.discPalette.getRGB(classValueIndices[self.rawdata[i].getclass().value]) 
    263263                elif hasContinuousClass and self.useDifferentColors: 
    264                     newColor = self.contPalette[self.noJitteringScaledData[classNameIndex][i]] 
     264                    newColor = self.contPalette.getRGB(self.noJitteringScaledData[classNameIndex][i]) 
    265265                else: 
    266                     newColor = Qt.black 
     266                    newColor = (0,0,0) 
    267267 
    268268                if self.useDifferentSymbols and classValueIndices: 
     
    277277                yPointsToAdd[(newColor, curveSymbol, showFilled)].append(y_positions[i]) 
    278278 
    279                 self.addTooltipKey(x_positions[i], y_positions[i], newColor, i) 
     279                self.addTooltipKey(x_positions[i], y_positions[i], QColor(*newColor), i) 
    280280 
    281281            # if we have a data subset that contains examples that don't exist in the original dataset we show them here 
     
    297297 
    298298                    if not self.subsetData.domain.classVar or self.subsetData[i].getclass().isSpecial(): 
    299                         newColor = Qt.black 
     299                        newColor = (0,0,0) 
    300300                    else: 
    301301                        if classValueIndices: 
    302                             newColor = self.discPalette[classValueIndices[self.subsetData[i].getclass().value]] 
     302                            newColor = self.discPalette.getRGB(classValueIndices[self.subsetData[i].getclass().value]) 
    303303                        else: 
    304                             newColor = self.contPalette[self.scaleExampleValue(self.subsetData[i], classNameIndex)] 
     304                            newColor = self.contPalette.getRGB(self.scaleExampleValue(self.subsetData[i], classNameIndex)) 
    305305 
    306306                    if self.useDifferentSymbols and hasDiscreteClass and not self.subsetData[i].getclass().isSpecial(): 
     
    343343            for i in range(dataSize): 
    344344                if not validData[i]: continue 
    345                 if self.useDifferentColors: newColor = self.discPalette[classValueIndices[self.rawdata[i].getclass().value]] 
    346                 else:                       newColor = Qt.black 
     345                if self.useDifferentColors: newColor = self.discPalette.getRGB(classValueIndices[self.rawdata[i].getclass().value]) 
     346                else:                       newColor = (0,0,0) 
    347347                if self.useDifferentSymbols: curveSymbol = self.curveSymbols[classValueIndices[self.rawdata[i].getclass().value]] 
    348348                else:                        curveSymbol = self.curveSymbols[0] 
    349  
     349                #print newColor, curveSymbol, self.showFilledSymbols 
    350350                if not xPointsToAdd.has_key((newColor, curveSymbol, self.showFilledSymbols)): 
    351351                    xPointsToAdd[(newColor, curveSymbol, self.showFilledSymbols)] = [] 
     
    354354                yPointsToAdd[(newColor, curveSymbol, self.showFilledSymbols)].append(y_positions[i]) 
    355355 
    356                 self.addTooltipKey(x_positions[i], y_positions[i], newColor, i) 
     356                self.addTooltipKey(x_positions[i], y_positions[i], QColor(*newColor), i) 
    357357 
    358358        # draw all the points with a small number of curves 
     
    360360            xData = xPointsToAdd[(color, symbol, showFilled)] 
    361361            yData = yPointsToAdd[(color, symbol, showFilled)] 
    362             self.addCurve(str(i), color, color, self.pointWidth, symbol = symbol, xData = xData, yData = yData, showFilledSymbols = showFilled) 
     362            self.addCurve(str(i), QColor(*color), QColor(*color), self.pointWidth, symbol = symbol, xData = xData, yData = yData, showFilledSymbols = showFilled) 
    363363 
    364364        # ############################################################## 
  • orange/OrangeWidgets/Visualize/OWPolyvizGraph.py

    r3483 r3503  
    4343            i -= 1 
    4444        return ret 
    45      
     45 
    4646# return number of combinations where we select "select" from "total" 
    4747def combinations(select, total): 
    4848    return fact(total)/ (fact(total-select)*fact(select)) 
    4949 
    50  
    51 SYMBOL = 0 
    52 PENCOLOR = 1 
    53 BRUSHCOLOR = 2 
    54 XANCHORS = 3 
    55 YANCHORS = 4 
    5650 
    5751LINE_TOOLTIPS = 0 
     
    7064        OWGraph.__init__(self, parent, name) 
    7165        orngScalePolyvizData.__init__(self) 
    72          
     66 
    7367        self.lineLength = 2 
    7468        self.totalPossibilities = 0 # a variable used in optimization - tells us the total number of different attribute positions 
     
    9791        self.setAxisScaleDraw(QwtPlot.yLeft, HiddenScaleDraw()) 
    9892        scaleDraw = self.axisScaleDraw(QwtPlot.xBottom) 
    99         scaleDraw.setOptions(0)  
     93        scaleDraw.setOptions(0) 
    10094        scaleDraw.setTickLength(0, 0, 0) 
    10195        scaleDraw = self.axisScaleDraw(QwtPlot.yLeft) 
    102         scaleDraw.setOptions(0)  
     96        scaleDraw.setOptions(0) 
    10397        scaleDraw.setTickLength(0, 0, 0) 
    10498        self.setAxisScale(QwtPlot.yLeft, -1.20, 1.20, 1) 
     
    125119        self.removeMarkers() 
    126120        self.tips.removeAll() 
    127      
     121 
    128122        # initial var values 
    129123        self.showKNNModel = 0 
     
    137131        self.shownAttributes = labels 
    138132        polyvizLineCoordsX = []; polyvizLineCoordsY = []    # if class is discrete we will optimize drawing by storing computed values and adding less data curves to plot 
    139              
     133 
    140134        # we must have at least 3 attributes to be able to show anything 
    141135        if self.scaledData == None or len(labels) < 3: 
    142136            self.updateLayout() 
    143137            return 
    144          
     138 
    145139        dataSize = len(self.rawdata) 
    146140        hasClass = self.rawdata and self.rawdata.domain.classVar != None 
     
    152146 
    153147        self.setAxisScale(QwtPlot.xBottom, -1.20, 1.20 + 0.05 * self.showLegend, 1) 
    154          
     148 
    155149        # store indices to shown attributes 
    156150        indices = [self.attributeNameIndex[label] for label in labels] 
     
    162156        if hasDiscreteClass:        # if we have a discrete class 
    163157            valLen = len(self.rawdata.domain.classVar.values) 
    164             classValueIndices = getVariableValueIndices(self.rawdata, self.rawdata.domain.classVar.name)    # we create a hash table of variable values and their indices             
    165         else:     
     158            classValueIndices = getVariableValueIndices(self.rawdata, self.rawdata.domain.classVar.name)    # we create a hash table of variable values and their indices 
     159        else: 
    166160            valLen = 1 
    167161 
    168         # will we show different symbols?         
     162        # will we show different symbols? 
    169163        useDifferentSymbols = 0 
    170164        if self.useDifferentSymbols and hasDiscreteClass and valLen < len(self.curveSymbols): 
    171165            useDifferentSymbols = 1 
    172          
     166 
    173167        dataSize = len(self.rawdata) 
    174         curveData = [[0, 0, 0, QwtSymbol.Ellipse, Qt.black, Qt.black, [], []] for i in range(dataSize)] 
    175168 
    176169        # ########## 
     
    210203        XAnchorPositions = numpy.swapaxes(XAnchorPositions, 0,1) 
    211204        YAnchorPositions = numpy.swapaxes(YAnchorPositions, 0,1) 
    212              
     205 
    213206        selectedData = numpy.take(self.scaledData, indices, axis = 0) 
    214207        sum_i = numpy.add.reduce(selectedData) 
     
    221214        x_positions = numpy.sum(numpy.swapaxes(XAnchorPositions * numpy.swapaxes(selectedData, 0,1), 0,1), axis=0) * self.scaleFactor / sum_i 
    222215        y_positions = numpy.sum(numpy.swapaxes(YAnchorPositions * numpy.swapaxes(selectedData, 0,1), 0,1), axis=0) * self.scaleFactor / sum_i 
    223         validData = self.getValidList(indices)       
    224  
    225         for i in range(dataSize): 
    226             if validData[i] == 0: continue                        
    227             curveData[i][XANCHORS] = XAnchorPositions[i] 
    228             curveData[i][YANCHORS] = YAnchorPositions[i] 
     216        validData = self.getValidList(indices) 
    229217 
    230218        xPointsToAdd = {} 
     
    238226            table = orange.ExampleTable(domain) 
    239227 
    240             # build an example table             
     228            # build an example table 
    241229            for i in range(dataSize): 
    242230                if validData[i]: 
     
    250238                    kNNValues = [1.0 - val for val in kNNValues] 
    251239            else: 
    252                 if self.showCorrect: kNNValues = [1.0 - val for val in kNNValues] 
    253  
    254             # fill and edge color palettes  
     240                if self.showCorrect: 
     241                    kNNValues = [1.0 - val for val in kNNValues] 
     242 
     243            # fill and edge color palettes 
    255244            bwColors = ColorPaletteBW(-1, 55, 255) 
    256245 
     
    265254 
    266255            for i in range(len(table)): 
    267                 fillColor = bwColors.getColor(kNNValues[i]) 
    268                 edgeColor = classColors.getColor(classValueIndices[table[i].getclass().value]) 
     256                fillColor = bwColors.getRGB(kNNValues[i]) 
     257                edgeColor = classColors.getRGB(classValueIndices[table[i].getclass().value]) 
    269258                if not xPointsToAdd.has_key((fillColor, edgeColor, QwtSymbol.Ellipse, 1)): 
    270259                    xPointsToAdd[(fillColor, edgeColor, QwtSymbol.Ellipse, 1)] = [] 
     
    272261                xPointsToAdd[(fillColor, edgeColor, QwtSymbol.Ellipse, 1)].append(table[i][0].value) 
    273262                yPointsToAdd[(fillColor, edgeColor, QwtSymbol.Ellipse, 1)].append(table[i][1].value) 
    274                 self.addAnchorLine(x_positions[i], y_positions[i], curveData[i][XANCHORS], curveData[i][YANCHORS], fillColor, i, length) 
    275  
    276         # CONTINUOUS class  
     263                self.addAnchorLine(x_positions[i], y_positions[i], XAnchorPositions[i], YAnchorPositions[i], fillColor, i, length) 
     264 
     265        # CONTINUOUS class 
    277266        elif hasContinuousClass: 
    278267            for i in range(dataSize): 
     
    280269                if useDifferentColors:  newColor = self.contPalette[self.noJitteringScaledData[classNameIndex][i]] 
    281270                else:                   newColor = QColor(0,0,0) 
    282                 curveData[i][PENCOLOR] = newColor 
    283                 curveData[i][BRUSHCOLOR] = newColor 
    284271                self.addCurve(str(i), newColor, newColor, self.pointWidth, xData = [x_positions[i]], yData = [y_positions[i]]) 
    285                 self.addTooltipKey(x_positions[i], y_positions[i], curveData[i][XANCHORS], curveData[i][YANCHORS], newColor, i) 
    286                 self.addAnchorLine(x_positions[i], y_positions[i], curveData[i][XANCHORS], curveData[i][YANCHORS], newColor, i, length) 
     272                self.addTooltipKey(x_positions[i], y_positions[i], XAnchorPositions[i], YAnchorPositions[i], newColor, i) 
     273                self.addAnchorLine(x_positions[i], y_positions[i], XAnchorPositions[i], YAnchorPositions[i], (newColor.red(), newColor.green(), newColor.blue()), i, length) 
    287274 
    288275        # DISCRETE class or no class at all 
    289276        else: 
    290             color = Qt.black 
     277            color = (0,0,0) 
    291278            symbol = self.curveSymbols[0] 
    292279            for i in range(dataSize): 
     
    297284                        symbol = self.curveSymbols[ind] 
    298285                    if useDifferentColors: 
    299                         color = self.discPalette[ind] 
     286                        color = self.discPalette.getRGB(ind) 
    300287                if not xPointsToAdd.has_key((color, color, symbol, 1)): 
    301288                    xPointsToAdd[(color, color, symbol, 1)] = [] 
     
    303290                xPointsToAdd[(color, color, symbol, 1)].append(x_positions[i]) 
    304291                yPointsToAdd[(color, color, symbol, 1)].append(y_positions[i]) 
    305                  
    306                 self.addAnchorLine(x_positions[i], y_positions[i], curveData[i][XANCHORS], curveData[i][YANCHORS], color, i, length) 
    307                 self.addTooltipKey(x_positions[i], y_positions[i], curveData[i][XANCHORS], curveData[i][YANCHORS], color, i) 
     292 
     293                self.addAnchorLine(x_positions[i], y_positions[i], XAnchorPositions[i], YAnchorPositions[i], color, i, length) 
     294                self.addTooltipKey(x_positions[i], y_positions[i], XAnchorPositions[i], YAnchorPositions[i], QColor(*color), i) 
    308295 
    309296        # draw the points 
     
    311298            xData = xPointsToAdd[(fillColor, edgeColor, symbol, showFilled)] 
    312299            yData = yPointsToAdd[(fillColor, edgeColor, symbol, showFilled)] 
    313             self.addCurve(str(i), fillColor, edgeColor, self.pointWidth, symbol = symbol, xData = xData, yData = yData, showFilledSymbols = showFilled) 
     300            self.addCurve(str(i), QColor(*fillColor), QColor(*edgeColor), self.pointWidth, symbol = symbol, xData = xData, yData = yData, showFilledSymbols = showFilled) 
    314301 
    315302        self.showAnchorLines() 
     
    326313            if hasDiscreteClass: 
    327314                self.addMarker(self.rawdata.domain.classVar.name, 0.87, 1.06, Qt.AlignLeft) 
    328                      
     315 
    329316                classVariableValues = getVariableValuesSorted(self.rawdata, self.rawdata.domain.classVar.name) 
    330317                for index in range(len(classVariableValues)): 
     
    369356                lineX2 = (1.0 - kvoc)*xAnchors[j] + kvoc * lineX1 
    370357                lineY2 = (1.0 - kvoc)*yAnchors[j] + kvoc * lineY1 
    371              
     358 
    372359            self.xLinesToAdd[color] = self.xLinesToAdd.get(color, []) + [xAnchors[j], lineX2] 
    373360            self.yLinesToAdd[color] = self.yLinesToAdd.get(color, []) + [yAnchors[j], lineY2] 
     
    376363    def showAnchorLines(self): 
    377364        for i, color in enumerate(self.xLinesToAdd.keys()): 
    378             curve = UnconnectedLinesCurve(self, QPen(color), self.xLinesToAdd[color], self.yLinesToAdd[color]) 
     365            curve = UnconnectedLinesCurve(self, QPen(QColor(*color)), self.xLinesToAdd[color], self.yLinesToAdd[color]) 
    379366            self.insertCurve(curve) 
    380367 
     
    383370    def addTooltipKey(self, x, y, xAnchors, yAnchors, color, index): 
    384371        dictValue = "%.1f-%.1f"%(x, y) 
    385         if not self.dataMap.has_key(dictValue): self.dataMap[dictValue] = [] 
     372        if not self.dataMap.has_key(dictValue): 
     373            self.dataMap[dictValue] = [] 
    386374        self.dataMap[dictValue].append((x, y, xAnchors, yAnchors, color, index)) 
    387375 
     
    392380        redraw = 0 
    393381        if self.tooltipCurveKeys != [] or self.tooltipMarkers != []: redraw = 1 
    394          
     382 
    395383        for key in self.tooltipCurveKeys:  self.removeCurve(key) 
    396384        for marker in self.tooltipMarkers: self.removeMarker(marker) 
     
    403391            OWGraph.onMouseMoved(self, e) 
    404392            if redraw: self.replot() 
    405             return  
    406              
     393            return 
     394 
    407395        xFloat = self.invTransform(QwtPlot.xBottom, e.x()) 
    408396        yFloat = self.invTransform(QwtPlot.yLeft, e.y()) 
     
    421409            if self.tooltipKind == LINE_TOOLTIPS and bestDist < 0.05: 
    422410                for i in range(len(self.shownAttributes)): 
    423                      
     411 
    424412                    # draw lines 
    425413                    key = self.addCurve("Tooltip curve", color, color, 1, style = QwtCurve.Lines, symbol = QwtSymbol.None, xData = [x_i, xAnchors[i]], yData = [y_i, yAnchors[i]]) 
     
    436424                    self.setMarkerFont(marker, font) 
    437425                    self.tooltipMarkers.append(marker) 
    438                      
     426 
    439427            elif self.tooltipKind == VISIBLE_ATTRIBUTES or self.tooltipKind == ALL_ATTRIBUTES: 
    440428                if self.tooltipKind == VISIBLE_ATTRIBUTES: labels = self.shownAttributes 
     
    446434        OWGraph.onMouseMoved(self, e) 
    447435        self.update() 
    448          
     436 
    449437 
    450438    def generateAttrReverseLists(self, attrList, fullAttribList, tempList): 
     
    455443        return self.generateAttrReverseLists(attrList[1:], fullAttribList, tempList + tempList2) 
    456444 
    457     
     445 
    458446    # save projection (xAttr, yAttr, classVal) into a filename fileName 
    459447    def saveProjectionAsTabData(self, fileName, attrList): 
     
    482470        attrIndices = [self.attributeNameIndex[attr] for attr in attrList] 
    483471        validData = self.getValidList(attrIndices) 
    484          
     472 
    485473        array = self.createProjectionAsNumericArray(attrIndices, validData = validData, scaleFactor = self.scaleFactor, removeMissingData = 0) 
    486474        if array == None:       # if all examples have missing values 
    487475            return (None, None) 
    488          
     476 
    489477        selIndices, unselIndices = self.getSelectionsAsIndices(attrList, validData) 
    490                   
     478 
    491479        if addProjectedPositions: 
    492480            selected = orange.ExampleTable(domain, self.rawdata.selectref(selIndices)) 
     
    509497        if len(unselected) == 0: unselected = None 
    510498        return (selected, unselected) 
    511      
     499 
    512500 
    513501    def getSelectionsAsIndices(self, attrList, validData = None): 
     
    517505        if validData == None: 
    518506            validData = self.getValidList(attrIndices) 
    519          
     507 
    520508        array = self.createProjectionAsNumericArray(attrIndices, validData = validData, scaleFactor = self.scaleFactor, removeMissingData = 0) 
    521509        if array == None: 
     
    523511        array = numpy.transpose(array) 
    524512        return self.getSelectedPoints(array[0], array[1], validData) 
    525      
     513 
    526514 
    527515 
     
    549537            answer.append( temp ) 
    550538        return answer 
    551      
     539 
    552540 
    553541    def createAttrReverseList(self, attrLen): 
     
    588576                XAnchors = anchorList[u+1-minLength][0] 
    589577                YAnchors = anchorList[u+1-minLength][1] 
    590                  
     578 
    591579                for attrList in combinations: 
    592580                    attrs = attrList + [attributes[z]] # remove the value of this attribute subset 
     
    596584                    getPermutationList(indices, [], indPermutations, attrReverseDict == None) 
    597585 
    598                     if attrReverseDict != None: # if we received a dictionary, then we don't reverse attributes  
     586                    if attrReverseDict != None: # if we received a dictionary, then we don't reverse attributes 
    599587                        attrReverse = [[attrReverseDict[attr] for attr in attrs]] 
    600588 
     
    609597                    tempList = [] 
    610598 
    611                     # for every permutation compute how good it separates different classes             
     599                    # for every permutation compute how good it separates different classes 
    612600                    for permutation in indPermutations.values(): 
    613601                        for attrOrder in attrReverse: 
     
    621609                            table = self.createProjectionAsExampleTable(permutation, reverse = attrOrder, validData = validData, classList = classList, sum_i = sum_i, XAnchors = XAnchors, YAnchors = YAnchors, domain = domain) 
    622610                            accuracy, other_results = self.kNNOptimization.kNNComputeAccuracy(table) 
    623                          
     611 
    624612                            # save the permutation 
    625613                            if not self.onlyOnePerSubset: 
     
    627615                            else: 
    628616                                tempList.append((accuracy, other_results, len(table), [self.attributeNames[val] for val in permutation], attrOrder)) 
    629                                  
     617 
    630618                            self.triedPossibilities += 1 
    631619                            self.polyvizWidget.progressBarSet(100.0*self.triedPossibilities/float(self.totalPossibilities)) 
     
    667655                projs = orngVisFuncts.createProjections(numClasses, u+1) 
    668656                attrListLength = u+1 
    669                  
     657 
    670658                combinations = orngVisFuncts.combinations(range(z), u) 
    671659 
     
    677665                XAnchors = anchorList[u+1-minLength][0] 
    678666                YAnchors = anchorList[u+1-minLength][1] 
    679                  
     667 
    680668                for comb in combinations: 
    681669                    comb = comb + [z]  # remove the value of this attribute subset 
     
    693681                    getPermutationList(attrs, [], indPermutations, attrReverseDict == None) 
    694682 
    695                     if attrReverseDict != None: # if we received a dictionary, then we don't reverse attributes  
     683                    if attrReverseDict != None: # if we received a dictionary, then we don't reverse attributes 
    696684                        attrReverse = [[attrReverseDict[attr] for attr in attrs]] 
    697685 
     
    720708                                table = self.createProjectionAsExampleTable(permutation, reverse = attrOrder, validData = validData, classList = classList, sum_i = sum_i, XAnchors = XAnchors,  YAnchors = YAnchors, domain = domain) 
    721709                                accuracy, other_results = self.kNNOptimization.kNNComputeAccuracy(table) 
    722                              
     710 
    723711                                # save the permutation 
    724712                                if not self.onlyOnePerSubset: 
     
    726714                                else: 
    727715                                    tempList.append((accuracy, other_results, len(table), [self.attributeNames[val] for val in permutation], attrOrder)) 
    728                                      
     716 
    729717                                self.triedPossibilities += 1 
    730718                                self.kNNOptimization.setStatusBarText("Evaluated %s projections (%d attributes)..." % (orngVisFuncts.createStringFromNumber(self.triedPossibilities), z)) 
    731719                        except: 
    732720                            pass 
    733                              
     721 
    734722                    if self.onlyOnePerSubset and tempList: 
    735723                        (acc, other_results, lenTable, attrList, attrOrder) = self.kNNOptimization.getMaxFunct()(tempList) 
    736724                        addResultFunct(acc, other_results, lenTable, attrList, self.triedPossibilities, generalDict = {"reverse": attrOrder}) 
    737                 
     725 
    738726        secs = time.time() - startTime 
    739727        self.kNNOptimization.setStatusBarText("Finished evaluation (evaluated %s projections in %d min, %d sec)" % (orngVisFuncts.createStringFromNumber(self.triedPossibilities), secs/60, secs%60)) 
     
    756744        classListFull = numpy.transpose(self.rawdata.toNumpy("c")[0])[0] 
    757745        allAttrReverse = {} 
    758          
     746 
    759747        optimizedProjection = 1 
    760748        while optimizedProjection: 
    761749            optimizedProjection = 0 
    762750            significantImprovement = 0 
    763              
     751 
    764752            # in the first step try to find a better projection by substituting an existent attribute with a new one 
    765753            # in the second step try to find a better projection by adding a new attribute to the circle 
    766754            for iteration in range(2): 
    767                 if (maxProjectionLen != -1 and len(projection) + iteration > maxProjectionLen): continue     
     755                if (maxProjectionLen != -1 and len(projection) + iteration > maxProjectionLen): continue 
    768756                if iteration == 1 and optimizedProjection: continue # if we already found a better projection with replacing an attribute then don't try to add a new atribute 
    769757                strTotalAtts = orngVisFuncts.createStringFromNumber(lenOfAttributes) 
     
    774762                        allAttrReverse[len(projection) + iteration] = self.createAttrReverseList(len(projection) + iteration) 
    775763                    attrReverse = allAttrReverse[len(projection) + iteration] 
    776                      
     764 
    777765                for (attrIndex, attr) in enumerate(attributes): 
    778766                    if attr in projection: continue 
     
    784772                        rev = [0 for i in range(len(projection))] 
    785773                        projections = [(copy(projection), rev) for i in range(len(projection))] 
    786                          
     774 
    787775                    if iteration == 0:  # replace one attribute in each projection with attribute attr 
    788776                        count = len(projection) 
     
    806794                    validData = self.getValidList(projections[0][0]) 
    807795                    classList = numpy.compress(validData, classListFull) 
    808                      
     796 
    809797                    tempList = [] 
    810798                    for (testProj, reverse) in projections: 
     
    813801                        table = self.createProjectionAsExampleTable(testProj, reverse = reverse, validData = validData, classList = classList, XAnchors = XAnchors, YAnchors = YAnchors, domain = domain) 
    814802                        acc, other_results = self.kNNOptimization.kNNComputeAccuracy(table) 
    815                          
     803 
    816804                        # save the permutation 
    817805                        tempList.append((acc, other_results, len(table), testProj, reverse)) 
     
    820808                        qApp.processEvents()        # allow processing of other events 
    821809                        if self.kNNOptimization.isOptimizationCanceled(): return 
    822                          
     810 
    823811 
    824812                    # return only the best attribute placements 
     
    836824 
    837825 
    838                 # select the best new projection and say this is now our new projection to optimize     
     826                # select the best new projection and say this is now our new projection to optimize 
    839827                if len(listOfCanditates) > 0: 
    840828                    (accuracy, projection, reverse) = self.kNNOptimization.getMaxFunct()(listOfCanditates) 
     
    843831 
    844832 
    845      
     833 
    846834if __name__== "__main__": 
    847835    #Draw a simple graph 
    848     a = QApplication(sys.argv)         
     836    a = QApplication(sys.argv) 
    849837    c = OWPolyvizGraph() 
    850          
     838 
    851839    a.setMainWidget(c) 
    852840    c.show() 
  • orange/OrangeWidgets/Visualize/OWScatterPlotGraph.py

    r3483 r3503  
    272272                if colorIndex != -1: 
    273273                    if self.rawdata.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    274                         newColor = self.contPalette[self.noJitteringScaledData[colorIndex][i]] 
     274                        newColor = self.contPalette.getRGB(self.noJitteringScaledData[colorIndex][i]) 
    275275                    else: 
    276                         newColor = self.discPalette[colorIndices[self.rawdata[i][colorIndex].value]] 
    277                 else: newColor = Qt.black 
     276                        newColor = self.discPalette.getRGB(colorIndices[self.rawdata[i][colorIndex].value]) 
     277                else: newColor = (0,0,0) 
    278278 
    279279                Symbol = self.curveSymbols[0] 
     
    327327                        val = min(1.0, max(0.0, self.scaleExampleValue(self.subsetData[i], colorIndex)))    # scale to 0-1 interval 
    328328                        if self.rawdata.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    329                             newColor = self.contPalette[val] 
     329                            newColor = self.contPalette.getRGB(val) 
    330330                        else: 
    331                             newColor = self.discPalette[colorIndices[self.subsetData[i][colorIndex].value]] 
    332                     else: newColor = Qt.black 
     331                            newColor = self.discPalette.getRGB(colorIndices[self.subsetData[i][colorIndex].value]) 
     332                    else: newColor = (0,0,0) 
    333333 
    334334                    if shapeIndex != -1: Symbol = self.curveSymbols[shapeIndices[self.subsetData[i][shapeIndex].value]] 
     
    359359                xData = xPointsToAdd[(color, size, symbol, showFilled)] 
    360360                yData = yPointsToAdd[(color, size, symbol, showFilled)] 
    361                 self.addCurve(str(i), color, color, size, symbol = symbol, xData = xData, yData = yData, showFilledSymbols = showFilled) 
     361                self.addCurve(str(i), QColor(*color), QColor(*color), size, symbol = symbol, xData = xData, yData = yData, showFilledSymbols = showFilled) 
    362362 
    363363        # ############################################################## 
Note: See TracChangeset for help on using the changeset viewer.