Changeset 8666:43f480df71fa in orange


Ignore:
Timestamp:
08/11/11 14:01:27 (3 years ago)
Author:
Noughmad <Noughmad@…>
Branch:
default
Convert:
82bbfcf8ebc8671c695079dd2638d4a2a58a52b1
Message:

Create a legend item for continuous colors (currently only for vertical legend) and use it in ScatterPlot and ParallelCoordinates.

Location:
orange/OrangeWidgets
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/OWColorPalette.py

    r8042 r8241  
    539539        if type(index) == tuple: 
    540540            index, brightness = index 
    541         index = int(index) 
    542541         
    543542        if self.numberOfColors == -1:     # is this color for continuous attribute? 
     
    546545            return col 
    547546        else: 
     547            index = int(index) 
    548548            if index < len(self.rgbColors): 
    549549                if brightness == None: 
  • orange/OrangeWidgets/Prototypes/OWParallelGraphQt.py

    r8665 r8666  
    281281 
    282282        # show the legend 
    283         if self.dataHasDiscreteClass: 
     283        if self.dataHasClass: 
    284284            if self.dataDomain.classVar.varType == orange.VarTypes.Discrete: 
    285285                legendKeys = [] 
     
    295295                        self.legend().add_item(self.dataDomain.classVar.name, name, OWPoint(OWPoint.Rect, color, self.point_width)) 
    296296            else: 
    297                 l = len(attributes)-1 
    298                 xs = [l*1.15, l*1.20, l*1.20, l*1.15] 
    299                 count = 200; height = 1/200. 
    300                 for i in range(count): 
    301                     y = i/float(count) 
    302                     col = self.contPalette[y] 
    303                     curve = PolygonCurve(QPen(col), QBrush(col), xData = xs, yData = [y,y, y+height, y+height]) 
    304                     curve.attach(self) 
    305  
    306                 # add markers for min and max value of color attribute 
    307                 [minVal, maxVal] = self.attrValues[self.dataDomain.classVar.name] 
     297                values = self.attrValues[self.dataDomain.classVar.name] 
    308298                decimals = self.dataDomain.classVar.numberOfDecimals 
    309                 self.addMarker("%%.%df" % (decimals) % (minVal), xs[0] - l*0.02, 0.04, Qt.AlignLeft) 
    310                 self.addMarker("%%.%df" % (decimals) % (maxVal), xs[0] - l*0.02, 1.0 - 0.04, Qt.AlignLeft) 
     299                self.legend().add_color_gradient(self.dataDomain.classVar.name, ["%%.%df" % decimals % v for v in values]) 
    311300        else: 
    312301            self.legend().clear() 
  • orange/OrangeWidgets/Prototypes/OWScatterPlotGraphQt.py

    r8656 r8666  
    8787            sizeIndex = self.attributeNameIndex[sizeShapeAttr] 
    8888             
    89         showContinuousColorLegend = self.showLegend and colorIndex != -1 and self.dataDomain[colorIndex].varType == orange.VarTypes.Continuous 
     89        showContinuousColorLegend = colorIndex != -1 and self.dataDomain[colorIndex].varType == orange.VarTypes.Continuous 
    9090 
    9191        (xVarMin, xVarMax) = self.attrValues[xAttr] 
     
    340340        if self.showLegend == 1: 
    341341            legendKeys = {} 
    342             colorIndex = colorIndex if colorIndex != -1 and self.dataDomain[colorIndex].varType == orange.VarTypes.Discrete else -1 
    343             shapeIndex = shapeIndex if shapeIndex != -1 and self.dataDomain[shapeIndex].varType == orange.VarTypes.Discrete else -1 
    344             sizeIndex = sizeIndex if sizeIndex != -1 and self.dataDomain[sizeIndex].varType == orange.VarTypes.Discrete else -1 
     342            discColorIndex = colorIndex if colorIndex != -1 and self.dataDomain[colorIndex].varType == orange.VarTypes.Discrete else -1 
     343            discShapeIndex = shapeIndex if shapeIndex != -1 and self.dataDomain[shapeIndex].varType == orange.VarTypes.Discrete else -1 
     344            discSizeIndex = sizeIndex if sizeIndex != -1 and self.dataDomain[sizeIndex].varType == orange.VarTypes.Discrete else -1 
    345345                         
    346             singleLegend = len([index for index in [colorIndex, shapeIndex, sizeIndex] if index != -1]) == 1 
    347             if singleLegend: 
    348                 #Show only values 
    349                 legendJoin = lambda name, val: val 
    350             else: 
    351                 legendJoin = lambda name, val: name + "=" + val  
    352                  
    353             if colorIndex != -1: 
    354                 num = len(self.dataDomain[colorIndex].values) 
    355                 varValues = getVariableValuesSorted(self.dataDomain[colorIndex]) 
     346            if discColorIndex != -1: 
     347                num = len(self.dataDomain[discColorIndex].values) 
     348                varValues = getVariableValuesSorted(self.dataDomain[discColorIndex]) 
    356349                for ind in range(num): 
    357                     self.legend().add_item(self.dataDomain[colorIndex].name, varValues[ind], OWPoint(OWPoint.Ellipse, self.discPalette[ind], self.pointWidth)) 
    358  
    359             if shapeIndex != -1: 
    360                 num = len(self.dataDomain[shapeIndex].values) 
    361                 varValues = getVariableValuesSorted(self.dataDomain[shapeIndex]) 
     350                    self.legend().add_item(self.dataDomain[discColorIndex].name, varValues[ind], OWPoint(OWPoint.Ellipse, self.discPalette[ind], self.pointWidth)) 
     351 
     352            if discShapeIndex != -1: 
     353                num = len(self.dataDomain[discShapeIndex].values) 
     354                varValues = getVariableValuesSorted(self.dataDomain[discShapeIndex]) 
    362355                for ind in range(num): 
    363                     self.legend().add_item(self.dataDomain[shapeIndex].name, varValues[ind], OWPoint(self.curveSymbols[ind], Qt.black, self.pointWidth)) 
     356                    self.legend().add_item(self.dataDomain[discShapeIndex].name, varValues[ind], OWPoint(self.curveSymbols[ind], Qt.black, self.pointWidth)) 
    364357 
    365358            if sizeIndex != -1: 
    366                 num = len(self.dataDomain[sizeIndex].values) 
    367                 varValues = getVariableValuesSorted(self.dataDomain[sizeIndex]) 
     359                num = len(self.dataDomain[discSizeIndex].values) 
     360                varValues = getVariableValuesSorted(self.dataDomain[discSizeIndex]) 
    368361                for ind in range(num): 
    369                     self.legend().add_item(self.dataDomain[sizeIndex].name, varValues[ind], OWPoint(OWPoint.Ellipse, Qt.black, MIN_SHAPE_SIZE + round(ind*self.pointWidth/len(varValues)))) 
     362                    self.legend().add_item(self.dataDomain[discSizeIndex].name, varValues[ind], OWPoint(OWPoint.Ellipse, Qt.black, MIN_SHAPE_SIZE + round(ind*self.pointWidth/len(varValues)))) 
    370363 
    371364        # ############################################################## 
    372365        # draw color scale for continuous coloring attribute 
     366        qDebug('Show continuous legend? ' + str(colorIndex) + '  ' + repr(showContinuousColorLegend)) 
    373367        if colorIndex != -1 and showContinuousColorLegend: 
    374             x0 = xmax + xVar*1.0/100.0;  x1 = x0 + xVar*2.5/100.0 
    375             count = 200 
    376             height = yVar / float(count) 
    377             xs = [x0, x1, x1, x0] 
    378  
    379             for i in range(count): 
    380                 y = yVarMin + i*yVar/float(count) 
    381                 col = self.contPalette[i/float(count)] 
    382                 col.setAlpha(self.alphaValue) 
    383                 curve = PolygonCurve(QPen(col), QBrush(col)) 
    384                 curve.setData(xs, [y,y, y+height, y+height]) 
    385                 curve.attach(self) 
    386  
    387  
    388             # add markers for min and max value of color attribute 
    389             (colorVarMin, colorVarMax) = self.attrValues[colorAttr] 
    390             self.addMarker("%s = %%.%df" % (colorAttr, self.dataDomain[colorAttr].numberOfDecimals) % (colorVarMin), x0 - xVar*1./100.0, yVarMin + yVar*0.04, Qt.AlignLeft) 
    391             self.addMarker("%s = %%.%df" % (colorAttr, self.dataDomain[colorAttr].numberOfDecimals) % (colorVarMax), x0 - xVar*1./100.0, yVarMin + yVar*0.96, Qt.AlignLeft) 
    392  
     368            self.legend().add_color_gradient(colorAttr, [("%%.%df" % self.dataDomain[colorAttr].numberOfDecimals % v) for v in self.attrValues[colorAttr]]) 
     369             
    393370        self.replot() 
    394371 
  • orange/OrangeWidgets/plot/owlegend.py

    r8658 r8666  
    1313""" 
    1414 
    15 from PyQt4.QtGui import QGraphicsTextItem, QGraphicsRectItem, QGraphicsObject, QColor, QPen 
     15from PyQt4.QtGui import QGraphicsTextItem, QGraphicsRectItem, QGraphicsObject, QColor, QPen, QLinearGradient 
    1616from PyQt4.QtCore import QPointF, QRectF, Qt, QPropertyAnimation, QSizeF, qDebug 
    1717 
     
    8383    def paint(self, painter, option, widget): 
    8484        pass 
     85     
     86class OWLegendGradient(QGraphicsObject): 
     87     
     88    gradient_width = 20 
     89     
     90    def __init__(self, palette, values, parent): 
     91        QGraphicsObject.__init__(self, parent) 
     92        self.palette = palette 
     93        self.values = values 
     94        self.legend = parent 
     95        self.label_items = [QGraphicsTextItem(text, self) for text in values] 
     96        self.gradient_item = QGraphicsRectItem(self) 
     97        self.gradient = QLinearGradient() 
     98        self.gradient.setStops([(v, self.palette[v]) for v in [0,1] ]) 
     99        self.orientation = Qt.Horizontal 
     100        self.set_orientation(Qt.Vertical) 
     101         
     102    def set_orientation(self, orientation): 
     103        if self.orientation == orientation: 
     104            return 
     105             
     106        self.orientation = orientation 
     107         
     108        if orientation == Qt.Vertical: 
     109            height = self.label_items[0].boundingRect().height() 
     110            total_height = height * max(5, len(self.label_items)) 
     111            interval = (total_height - self.label_items[0].boundingRect().height()) / (len(self.label_items) -1) 
     112            self.gradient_item.setRect(10, 0, self.gradient_width, total_height) 
     113            self.gradient.setStart(10, 0) 
     114            self.gradient.setFinalStop(10, total_height) 
     115            self.gradient_item.setBrush(QBrush(self.gradient)) 
     116            self.gradient_item.setPen(QPen(Qt.NoPen)) 
     117            y = 0 
     118            x = 30 
     119            for item in self.label_items: 
     120                move_item_xy(item, x, y) 
     121                y += interval 
     122                 
     123    def boundingRect(self): 
     124        if self.orientation == Qt.Vertical: 
     125            return QRectF(10, 0, self.gradient_width + max([item.boundingRect().width() for item in self.label_items]), self.label_items[0].boundingRect().height() * max(5, len(self.label_items))) 
     126        else: 
     127            return QRectF(0, 0, ) 
     128         
     129    def paint(self, painter, option, widget): 
     130        pass 
     131         
    85132         
    86133class OWLegend(QGraphicsObject): 
     
    94141        Arbitrary categories can be created, for an example see :meth:`.OWPlot.update_axes`, which creates a special category 
    95142        for unused axes.  
    96          
     143        decimals 
    97144        .. image:: files/legend-categories.png 
    98145         
     
    150197            cat = curve.name[:i] 
    151198            name = curve.name[i+1:] 
    152         self.add_item('', curve.name, curve.point_item(0, 0, 0)) 
     199        self.add_item(cat, name, curve.point_item(0, 0, 0)) 
    153200         
    154201    def add_item(self, category, value, point): 
     
    159206            self.items[category] = [OWLegendTitle(category, self)] 
    160207        self.items[category].append(OWLegendItem(str(value), point, self)) 
     208        self.update() 
     209         
     210    def add_color_gradient(self, title, values): 
     211        if len(values) < 2: 
     212            # No point in showing a gradient with less that two values 
     213            return 
     214        if title in self.items: 
     215            self.remove_category(title) 
     216        item = OWLegendGradient(self.graph.contPalette, [str(v) for v in values], self) 
     217        self.items[title] = [OWLegendTitle(title, self), item] 
    161218        self.update() 
    162219         
     
    181238            for lst in self.items.itervalues(): 
    182239                for item in lst: 
     240                    if isinstance(item, OWLegendGradient): 
     241                        item.set_orientation(self._orientation) 
    183242                    if self.max_size.height() and y and y + item.boundingRect().height() > self.max_size.height(): 
    184243                        y = 0 
     
    194253                    y = y + max_h 
    195254                for item in lst: 
     255                    if isinstance(item, OWLegendGradient): 
     256                        item.set_orientation(self._orientation) 
    196257                    if self.max_size.width() and x and x + item.boundingRect().width() > self.max_size.width(): 
    197258                        x = 0 
     
    239300            self.update() 
    240301             
     302    def orientation(self): 
     303        return self._orientation 
     304             
    241305    def set_pos_animated(self, pos): 
    242306        if (self.pos() - pos).manhattanLength() < 6 or not self.graph.use_animations: 
Note: See TracChangeset for help on using the changeset viewer.