Changeset 11823:c92ee492d90d in orange


Ignore:
Timestamp:
01/02/14 12:57:44 (3 months ago)
Author:
astaric <anze.staric@…>
Branch:
default
committer:
astaric <anze.staric@gmail.com> 1388665309 -3600
Message:

Consistent code style.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeWidgets/Visualize/OWParallelGraph.py

    r9671 r11823  
    99 
    1010NO_STATISTICS = 0 
    11 MEANS  = 1 
     11MEANS = 1 
    1212MEDIAN = 2 
    1313 
     14 
    1415class OWParallelGraph(OWGraph, orngScaleData): 
    15     def __init__(self, parallelDlg, parent = None, name = None): 
     16    def __init__(self, parallelDlg, parent=None, name=None): 
    1617        OWGraph.__init__(self, parent, name) 
    1718        orngScaleData.__init__(self) 
     
    4344        self.axisScaleDraw(QwtPlot.yLeft).enableComponent(QwtScaleDraw.Ticks, 0) 
    4445 
    45     def setData(self, data, subsetData = None, **args): 
     46    def setData(self, data, subsetData=None, **args): 
    4647        OWGraph.setData(self, data) 
    4748        orngScaleData.setData(self, data, subsetData, **args) 
    4849        self.domainContingency = None 
    49          
    5050 
    5151 
    5252    # update shown data. Set attributes, coloring by className .... 
    53     def updateData(self, attributes, midLabels = None, updateAxisScale = 1): 
    54         self.removeDrawingCurves(removeLegendItems = 0, removeMarkers = 1)  # don't delete legend items 
     53    def updateData(self, attributes, midLabels=None, updateAxisScale=1): 
     54        self.removeDrawingCurves(removeLegendItems=0, removeMarkers=1)  # don't delete legend items 
    5555        if attributes != self.visualizedAttributes: 
    5656            self.selectionConditions = {}       # reset selections 
     
    7171 
    7272        # set the limits for panning 
    73         self.xPanningInfo = (1, 0, len(attributes)-1) 
    74         self.yPanningInfo = (0, 0, 0)   # we don't enable panning in y direction so it doesn't matter what values we put in for the limits 
     73        self.xPanningInfo = (1, 0, len(attributes) - 1) 
     74        self.yPanningInfo = ( 
     75        0, 0, 0)   # we don't enable panning in y direction so it doesn't matter what values we put in for the limits 
    7576 
    7677        if updateAxisScale: 
    77             if self.showAttrValues: self.setAxisScale(QwtPlot.yLeft, -0.04, 1.04, 1) 
    78             else:                   self.setAxisScale(QwtPlot.yLeft, -0.02, 1.02, 1) 
     78            if self.showAttrValues: 
     79                self.setAxisScale(QwtPlot.yLeft, -0.04, 1.04, 1) 
     80            else: 
     81                self.setAxisScale(QwtPlot.yLeft, -0.02, 1.02, 1) 
    7982 
    8083            if self.autoUpdateAxes: 
     
    8790                M = self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue() 
    8891                if m < 0 or M > len(attributes) - 2: 
    89                     self.setAxisScale(QwtPlot.xBottom, 0, len(attributes)-1, 1) 
    90  
    91         self.setAxisScaleDraw(QwtPlot.xBottom, DiscreteAxisScaleDraw([self.getAttributeLabel(attr) for attr in attributes])) 
     92                    self.setAxisScale(QwtPlot.xBottom, 0, len(attributes) - 1, 1) 
     93 
     94        self.setAxisScaleDraw(QwtPlot.xBottom, 
     95                              DiscreteAxisScaleDraw([self.getAttributeLabel(attr) for attr in attributes])) 
    9296        #self.setAxisScaleDraw(QwtPlot.yLeft, HiddenScaleDraw()) 
    9397        self.setAxisMaxMajor(QwtPlot.xBottom, len(attributes)) 
     
    107111        # draw the data 
    108112        # ############################################ 
    109         subsetIdsToDraw = self.haveSubsetData and dict([(self.rawSubsetData[i].id, 1) for i in self.getValidSubsetIndices(indices)]) or {} 
     113        subsetIdsToDraw = self.haveSubsetData and dict( 
     114            [(self.rawSubsetData[i].id, 1) for i in self.getValidSubsetIndices(indices)]) or {} 
    110115        validData = self.getValidList(indices) 
    111116        mainCurves = {} 
     
    118123 
    119124            if not self.dataHasClass: 
    120                 newColor = (0,0,0) 
     125                newColor = (0, 0, 0) 
    121126            elif self.dataHasContinuousClass: 
    122127                newColor = self.contPalette.getRGB(self.noJitteringScaledData[self.dataClassIndex][i]) 
     
    127132 
    128133            # if we have selected some conditions and the example does not match it we show it as a subset data 
    129             if 0 in [data[index] >= self.selectionConditions[name][0] and data[index] <= self.selectionConditions[name][1] for (name, index) in conditions.items()]: 
     134            if 0 in [data[index] >= self.selectionConditions[name][0] and data[index] <= self.selectionConditions[name][ 
     135                1] for (name, index) in conditions.items()]: 
    130136                alpha = self.alphaValue2 
    131137                curves = subCurves 
     
    159165                data = [self.scaledSubsetData[index][i] for index in indices] 
    160166                if not self.dataDomain.classVar or self.rawSubsetData[i].getclass().isSpecial(): 
    161                     newColor = (0,0,0) 
     167                    newColor = (0, 0, 0) 
    162168                elif self.dataHasContinuousClass: 
    163169                    newColor = self.contPalette.getRGB(self.noJitteringScaledSubsetData[self.dataClassIndex][i]) 
     
    165171                    newColor = self.discPalette.getRGB(self.originalSubsetData[self.dataClassIndex][i]) 
    166172 
    167                 if 0 in [data[index] >= self.selectionConditions[name][0] and data[index] <= self.selectionConditions[name][1] for (name, index) in conditions.items()]: 
     173                if 0 in [data[index] >= self.selectionConditions[name][0] and data[index] <= 
     174                        self.selectionConditions[name][1] for (name, index) in conditions.items()]: 
    168175                    newColor += (self.alphaValue2,) 
    169176                    curves = subCurves 
     
    181188        for key in keys: 
    182189            curve = ParallelCoordinatesCurve(len(attributes), mainCurves[key], key) 
    183             if self.useAntialiasing:   
     190            if self.useAntialiasing: 
    184191                curve.setRenderHint(QwtPlotItem.RenderAntialiased) 
    185192            if self.useSplines: 
    186193                curve.setCurveAttribute(QwtPlotCurve.Fitted) 
    187 #                curve.setCurveFitter(QwtSplineCurveFitter()) 
     194            #                curve.setCurveFitter(QwtSplineCurveFitter()) 
    188195            curve.attach(self) 
    189196 
     
    193200        for key in keys: 
    194201            curve = ParallelCoordinatesCurve(len(attributes), subCurves[key], key) 
    195             if self.useAntialiasing:  
     202            if self.useAntialiasing: 
    196203                curve.setRenderHint(QwtPlotItem.RenderAntialiased) 
    197             if self.useSplines:       
     204            if self.useSplines: 
    198205                curve.setCurveAttribute(QwtPlotCurve.Fitted) 
    199206            curve.attach(self) 
     
    209216        # draw vertical lines that represent attributes 
    210217        for i in range(len(attributes)): 
    211             self.addCurve("", lineWidth = 2, style = QwtPlotCurve.Lines, symbol = QwtSymbol.NoSymbol, xData = [i,i], yData = [0,1]) 
     218            self.addCurve("", lineWidth=2, style=QwtPlotCurve.Lines, symbol=QwtSymbol.NoSymbol, xData=[i, i], 
     219                          yData=[0, 1]) 
    212220            if self.showAttrValues == 1: 
    213221                attr = self.dataDomain[attributes[i]] 
     
    215223                    strVal1 = "%%.%df" % (attr.numberOfDecimals) % (self.attrValues[attr.name][0]) 
    216224                    strVal2 = "%%.%df" % (attr.numberOfDecimals) % (self.attrValues[attr.name][1]) 
    217                     align1 = i == 0 and Qt.AlignRight | Qt.AlignBottom or i == len(attributes)-1 and Qt.AlignLeft | Qt.AlignBottom or Qt.AlignHCenter | Qt.AlignBottom 
    218                     align2 = i == 0 and Qt.AlignRight | Qt.AlignTop or i == len(attributes)-1 and Qt.AlignLeft | Qt.AlignTop or Qt.AlignHCenter | Qt.AlignTop 
    219                     self.addMarker(strVal1, i, 0.0-0.01, alignment = align1) 
    220                     self.addMarker(strVal2, i, 1.0+0.01, alignment = align2) 
     225                    align1 = i == 0 and Qt.AlignRight | Qt.AlignBottom or i == len( 
     226                        attributes) - 1 and Qt.AlignLeft | Qt.AlignBottom or Qt.AlignHCenter | Qt.AlignBottom 
     227                    align2 = i == 0 and Qt.AlignRight | Qt.AlignTop or i == len( 
     228                        attributes) - 1 and Qt.AlignLeft | Qt.AlignTop or Qt.AlignHCenter | Qt.AlignTop 
     229                    self.addMarker(strVal1, i, 0.0 - 0.01, alignment=align1) 
     230                    self.addMarker(strVal2, i, 1.0 + 0.01, alignment=align2) 
    221231 
    222232                elif attr.varType == orange.VarTypes.Discrete: 
     
    225235                    for pos in range(len(attrVals)): 
    226236                        # show a rectangle behind the marker 
    227                         self.addMarker(attrVals[pos], i+0.01, float(1+2*pos)/float(2*valsLen), alignment = Qt.AlignRight | Qt.AlignVCenter, bold = 1, brushColor = Qt.white) 
     237                        self.addMarker(attrVals[pos], i + 0.01, float(1 + 2 * pos) / float(2 * valsLen), 
     238                                       alignment=Qt.AlignRight | Qt.AlignVCenter, bold=1, brushColor=Qt.white) 
    228239 
    229240        # ############################################## 
     
    236247                    data.append([()]) 
    237248                    continue  # only for continuous attributes 
    238                 array = numpy.compress(numpy.equal(self.validDataArray[indices[i]], 1), self.scaledData[indices[i]])  # remove missing values 
     249                array = numpy.compress(numpy.equal(self.validDataArray[indices[i]], 1), 
     250                                       self.scaledData[indices[i]])  # remove missing values 
    239251 
    240252                if not self.dataHasClass or self.dataHasContinuousClass:    # no class 
     
    242254                        m = array.mean() 
    243255                        dev = array.std() 
    244                         data.append([(m-dev, m, m+dev)]) 
     256                        data.append([(m - dev, m, m + dev)]) 
    245257                    elif self.showStatistics == MEDIAN: 
    246258                        sorted = numpy.sort(array) 
    247259                        if len(sorted) > 0: 
    248                             data.append([(sorted[int(len(sorted)/4.0)], sorted[int(len(sorted)/2.0)], sorted[int(len(sorted)*0.75)])]) 
     260                            data.append([(sorted[int(len(sorted) / 4.0)], sorted[int(len(sorted) / 2.0)], 
     261                                          sorted[int(len(sorted) * 0.75)])]) 
    249262                        else: 
    250                             data.append([(0,0,0)]) 
     263                            data.append([(0, 0, 0)]) 
    251264                else: 
    252265                    curr = [] 
     
    254267                    classValueIndices = getVariableValueIndices(self.dataDomain.classVar) 
    255268                    for c in range(len(classValues)): 
    256                         scaledVal = ((classValueIndices[classValues[c]] * 2) + 1) / float(2*len(classValueIndices)) 
    257                         nonMissingValues = numpy.compress(numpy.equal(self.validDataArray[indices[i]], 1), self.noJitteringScaledData[self.dataClassIndex])  # remove missing values 
     269                        scaledVal = ((classValueIndices[classValues[c]] * 2) + 1) / float(2 * len(classValueIndices)) 
     270                        nonMissingValues = numpy.compress(numpy.equal(self.validDataArray[indices[i]], 1), 
     271                                                          self.noJitteringScaledData[ 
     272                                                              self.dataClassIndex])  # remove missing values 
    258273                        arr_c = numpy.compress(numpy.equal(nonMissingValues, scaledVal), array) 
    259274                        if len(arr_c) == 0: 
    260                             curr.append((0,0,0)); continue 
     275                            curr.append((0, 0, 0)); 
     276                            continue 
    261277                        if self.showStatistics == MEANS: 
    262278                            m = arr_c.mean() 
    263279                            dev = arr_c.std() 
    264                             curr.append((m-dev, m, m+dev)) 
     280                            curr.append((m - dev, m, m + dev)) 
    265281                        elif self.showStatistics == MEDIAN: 
    266282                            sorted = numpy.sort(arr_c) 
    267                             curr.append((sorted[int(len(arr_c)/4.0)], sorted[int(len(arr_c)/2.0)], sorted[int(len(arr_c)*0.75)])) 
     283                            curr.append((sorted[int(len(arr_c) / 4.0)], sorted[int(len(arr_c) / 2.0)], 
     284                                         sorted[int(len(arr_c) * 0.75)])) 
    268285                    data.append(curr) 
    269286 
     
    272289                for c in range(len(data[i])): 
    273290                    if data[i][c] == (): continue 
    274                     x = i - 0.03*(len(data[i])-1)/2.0 + c*0.03 
     291                    x = i - 0.03 * (len(data[i]) - 1) / 2.0 + c * 0.03 
    275292                    col = QColor(self.discPalette[c]) 
    276293                    col.setAlpha(self.alphaValue2) 
    277                     self.addCurve("", col, col, 3, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData = [x,x,x], yData = [data[i][c][0], data[i][c][1], data[i][c][2]], lineWidth = 4) 
    278                     self.addCurve("", col, col, 1, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData = [x-0.03, x+0.03], yData = [data[i][c][0], data[i][c][0]], lineWidth = 4) 
    279                     self.addCurve("", col, col, 1, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData = [x-0.03, x+0.03], yData = [data[i][c][1], data[i][c][1]], lineWidth = 4) 
    280                     self.addCurve("", col, col, 1, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData = [x-0.03, x+0.03], yData = [data[i][c][2], data[i][c][2]], lineWidth = 4) 
     294                    self.addCurve("", col, col, 3, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData=[x, x, x], 
     295                                  yData=[data[i][c][0], data[i][c][1], data[i][c][2]], lineWidth=4) 
     296                    self.addCurve("", col, col, 1, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData=[x - 0.03, x + 0.03], 
     297                                  yData=[data[i][c][0], data[i][c][0]], lineWidth=4) 
     298                    self.addCurve("", col, col, 1, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData=[x - 0.03, x + 0.03], 
     299                                  yData=[data[i][c][1], data[i][c][1]], lineWidth=4) 
     300                    self.addCurve("", col, col, 1, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData=[x - 0.03, x + 0.03], 
     301                                  yData=[data[i][c][2], data[i][c][2]], lineWidth=4) 
    281302 
    282303            # draw lines with mean/median values 
     
    284305            if not self.dataHasClass or self.dataHasContinuousClass: 
    285306                classCount = 1 # no class 
    286             else: classCount = len(self.dataDomain.classVar.values) 
     307            else: 
     308                classCount = len(self.dataDomain.classVar.values) 
    287309            for c in range(classCount): 
    288                 diff = - 0.03*(classCount-1)/2.0 + c*0.03 
     310                diff = - 0.03 * (classCount - 1) / 2.0 + c * 0.03 
    289311                ys = [] 
    290312                xs = [] 
    291313                for i in range(len(data)): 
    292                     if data[i] != [()]: ys.append(data[i][c][1]); xs.append(i+diff) 
     314                    if data[i] != [()]: 
     315                        ys.append(data[i][c][1]); xs.append(i + diff) 
    293316                    else: 
    294317                        if len(xs) > 1: 
    295318                            col = QColor(self.discPalette[c]) 
    296319                            col.setAlpha(self.alphaValue2) 
    297                             self.addCurve("", col, col, 1, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData = xs, yData = ys, lineWidth = 4) 
    298                         xs = []; ys = [] 
     320                            self.addCurve("", col, col, 1, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData=xs, yData=ys, 
     321                                          lineWidth=4) 
     322                        xs = []; 
     323                        ys = [] 
    299324                col = QColor(self.discPalette[c]) 
    300325                col.setAlpha(self.alphaValue2) 
    301                 self.addCurve("", col, col, 1, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData = xs, yData = ys, lineWidth = 4) 
     326                self.addCurve("", col, col, 1, QwtPlotCurve.Lines, QwtSymbol.NoSymbol, xData=xs, yData=ys, lineWidth=4) 
    302327 
    303328 
     
    306331        if midLabels: 
    307332            for j in range(len(midLabels)): 
    308                 self.addMarker(midLabels[j], j+0.5, 1.0, alignment = Qt.AlignCenter | Qt.AlignTop) 
     333                self.addMarker(midLabels[j], j + 0.5, 1.0, alignment=Qt.AlignCenter | Qt.AlignTop) 
    309334 
    310335        # show the legend 
     
    320345                    self.oldLegendKeys = legendKeys 
    321346                    self.legend().clear() 
    322                     self.addCurve("<b>" + self.dataDomain.classVar.name + ":</b>", QColor(0,0,0), QColor(0,0,0), 0, symbol = QwtSymbol.NoSymbol, enableLegend = 1) 
     347                    self.addCurve("<b>" + self.dataDomain.classVar.name + ":</b>", QColor(0, 0, 0), QColor(0, 0, 0), 0, 
     348                                  symbol=QwtSymbol.NoSymbol, enableLegend=1) 
    323349                    for (name, color) in legendKeys: 
    324                         self.addCurve(name, color, color, 15, symbol = QwtSymbol.Rect, enableLegend = 1) 
    325             else: 
    326                 l = len(attributes)-1 
    327                 xs = [l*1.15, l*1.20, l*1.20, l*1.15] 
    328                 count = 200; height = 1/200. 
     350                        self.addCurve(name, color, color, 15, symbol=QwtSymbol.Rect, enableLegend=1) 
     351            else: 
     352                l = len(attributes) - 1 
     353                xs = [l * 1.15, l * 1.20, l * 1.20, l * 1.15] 
     354                count = 200; 
     355                height = 1 / 200. 
    329356                for i in range(count): 
    330                     y = i/float(count) 
     357                    y = i / float(count) 
    331358                    col = self.contPalette[y] 
    332                     curve = PolygonCurve(QPen(col), QBrush(col), xData = xs, yData = [y,y, y+height, y+height]) 
     359                    curve = PolygonCurve(QPen(col), QBrush(col), xData=xs, yData=[y, y, y + height, y + height]) 
    333360                    curve.attach(self) 
    334361 
     
    336363                [minVal, maxVal] = self.attrValues[self.dataDomain.classVar.name] 
    337364                decimals = self.dataDomain.classVar.numberOfDecimals 
    338                 self.addMarker("%%.%df" % (decimals) % (minVal), xs[0] - l*0.02, 0.04, Qt.AlignLeft) 
    339                 self.addMarker("%%.%df" % (decimals) % (maxVal), xs[0] - l*0.02, 1.0 - 0.04, Qt.AlignLeft) 
     365                self.addMarker("%%.%df" % (decimals) % (minVal), xs[0] - l * 0.02, 0.04, Qt.AlignLeft) 
     366                self.addMarker("%%.%df" % (decimals) % (maxVal), xs[0] - l * 0.02, 1.0 - 0.04, Qt.AlignLeft) 
    340367        else: 
    341368            self.legend().clear() 
     
    353380 
    354381        # we create a hash table of possible class values (happens only if we have a discrete class) 
    355         classValueSorted  = getVariableValuesSorted(self.dataDomain.classVar) 
     382        classValueSorted = getVariableValuesSorted(self.dataDomain.classVar) 
    356383        if self.domainContingency == None: 
    357384            self.domainContingency = orange.DomainContingency(self.rawData) 
     
    365392            else: 
    366393                maxVal = max(maxVal, max([max(val or [1]) for val in self.domainContingency[attr].values()] or [1])) 
    367                  
    368394 
    369395        for graphAttrIndex, index in enumerate(indices): 
     
    377403            else: 
    378404                contingency = self.domainContingency[index] 
    379                                  
     405 
    380406            attrLen = len(attr.values) 
    381407 
     
    392418                    print >> sys.stderr, ex, attrVal, contingency 
    393419                    continue 
    394                  
     420 
    395421                for i in range(clsCount): 
    396422                    clsVal = classValueSorted[i] 
     
    399425                    newColor.setAlpha(self.alphaValue) 
    400426 
    401                     width = float(attrValCont[clsVal]*0.5) / float(maxVal) 
    402                     interval = 1.0/float(2*attrLen) 
    403                     yOff = float(1.0 + 2.0*j)/float(2*attrLen) 
    404                     height = 0.7/float(clsCount*attrLen) 
    405  
    406                     yLowBott = yOff + float(clsCount*height)/2.0 - i*height 
    407                     curve = PolygonCurve(QPen(newColor), QBrush(newColor), xData = [graphAttrIndex, graphAttrIndex + width, graphAttrIndex + width, graphAttrIndex], yData = [yLowBott, yLowBott, yLowBott - height, yLowBott - height], tooltip = (self.dataDomain[index].name, variableValueSorted[j], len(self.rawData), [(clsVal, attrValCont[clsVal]) for clsVal in classValueSorted])) 
     427                    width = float(attrValCont[clsVal] * 0.5) / float(maxVal) 
     428                    interval = 1.0 / float(2 * attrLen) 
     429                    yOff = float(1.0 + 2.0 * j) / float(2 * attrLen) 
     430                    height = 0.7 / float(clsCount * attrLen) 
     431 
     432                    yLowBott = yOff + float(clsCount * height) / 2.0 - i * height 
     433                    curve = PolygonCurve(QPen(newColor), QBrush(newColor), 
     434                                         xData=[graphAttrIndex, graphAttrIndex + width, graphAttrIndex + width, 
     435                                                graphAttrIndex], 
     436                                         yData=[yLowBott, yLowBott, yLowBott - height, yLowBott - height], tooltip=( 
     437                        self.dataDomain[index].name, variableValueSorted[j], len(self.rawData), 
     438                        [(clsVal, attrValCont[clsVal]) for clsVal in classValueSorted])) 
    408439                    curve.attach(self) 
    409440 
     
    421452                attr = self.dataDomain[self.visualizedAttributes[index]] 
    422453                if attr.varType == orange.VarTypes.Continuous: 
    423                     condition = self.selectionConditions.get(attr.name, [0,1]) 
    424                     val = self.attrValues[attr.name][0] + condition[pos] * (self.attrValues[attr.name][1] - self.attrValues[attr.name][0]) 
     454                    condition = self.selectionConditions.get(attr.name, [0, 1]) 
     455                    val = self.attrValues[attr.name][0] + condition[pos] * ( 
     456                    self.attrValues[attr.name][1] - self.attrValues[attr.name][0]) 
    425457                    strVal = attr.name + "= %%.%df" % (attr.numberOfDecimals) % (val) 
    426458                    QToolTip.showText(ev.globalPos(), strVal) 
    427459            else: 
    428460                for curve in self.itemList(): 
    429                     if type(curve) == PolygonCurve and curve.boundingRect().contains(x,y) and getattr(curve, "tooltip", None): 
     461                    if type(curve) == PolygonCurve and curve.boundingRect().contains(x, y) and getattr(curve, "tooltip", 
     462                                                                                                       None): 
    430463                        (name, value, total, dist) = curve.tooltip 
    431464                        count = sum([v[1] for v in dist]) 
    432465                        if count == 0: continue 
    433                         tooltipText = "Attribute: <b>%s</b><br>Value: <b>%s</b><br>Total instances: <b>%i</b> (%.1f%%)<br>Class distribution:<br>" % (name, value, count, 100.0*count/float(total)) 
     466                        tooltipText = "Attribute: <b>%s</b><br>Value: <b>%s</b><br>Total instances: <b>%i</b> (%.1f%%)<br>Class distribution:<br>" % ( 
     467                        name, value, count, 100.0 * count / float(total)) 
    434468                        for (val, n) in dist: 
    435                             tooltipText += "&nbsp; &nbsp; <b>%s</b> : <b>%i</b> (%.1f%%)<br>" % (val, n, 100.0*float(n)/float(count)) 
     469                            tooltipText += "&nbsp; &nbsp; <b>%s</b> : <b>%i</b> (%.1f%%)<br>" % ( 
     470                            val, n, 100.0 * float(n) / float(count)) 
    436471                        QToolTip.showText(ev.globalPos(), tooltipText[:-4]) 
    437472 
     
    447482            if index >= len(self.visualizedAttributes) or index < 0: continue 
    448483            intX = self.transform(QwtPlot.xBottom, index) 
    449             bottom = self.transform(QwtPlot.yLeft, self.selectionConditions.get(self.visualizedAttributes[index], [0,1])[0]) 
    450             bottomRect = QRect(intX-self.bottomPixmap.width()/2, bottom, self.bottomPixmap.width(), self.bottomPixmap.height()) 
    451             if bottomRect.contains(QPoint(x,y)): return 1, (index, 0) 
    452             top = self.transform(QwtPlot.yLeft, self.selectionConditions.get(self.visualizedAttributes[index], [0,1])[1]) 
    453             topRect = QRect(intX-self.topPixmap.width()/2, top-self.topPixmap.height(), self.topPixmap.width(), self.topPixmap.height()) 
    454             if topRect.contains(QPoint(x,y)): return 1, (index, 1) 
     484            bottom = self.transform(QwtPlot.yLeft, 
     485                                    self.selectionConditions.get(self.visualizedAttributes[index], [0, 1])[0]) 
     486            bottomRect = QRect(intX - self.bottomPixmap.width() / 2, bottom, self.bottomPixmap.width(), 
     487                               self.bottomPixmap.height()) 
     488            if bottomRect.contains(QPoint(x, y)): return 1, (index, 0) 
     489            top = self.transform(QwtPlot.yLeft, 
     490                                 self.selectionConditions.get(self.visualizedAttributes[index], [0, 1])[1]) 
     491            topRect = QRect(intX - self.topPixmap.width() / 2, top - self.topPixmap.height(), self.topPixmap.width(), 
     492                            self.topPixmap.height()) 
     493            if topRect.contains(QPoint(x, y)): return 1, (index, 1) 
    455494        return 0, (0, 0) 
    456495 
     
    472511            index, pos = self.pressedArrow 
    473512            attr = self.dataDomain[self.visualizedAttributes[index]] 
    474             oldCondition = self.selectionConditions.get(attr.name, [0,1]) 
     513            oldCondition = self.selectionConditions.get(attr.name, [0, 1]) 
    475514            oldCondition[pos] = yFloat 
    476515            self.selectionConditions[attr.name] = oldCondition 
    477             self.updateData(self.visualizedAttributes, self.visualizedMidLabels, updateAxisScale = 0) 
     516            self.updateData(self.visualizedAttributes, self.visualizedMidLabels, updateAxisScale=0) 
    478517 
    479518            if attr.varType == orange.VarTypes.Continuous: 
    480                 val = self.attrValues[attr.name][0] + oldCondition[pos] * (self.attrValues[attr.name][1] - self.attrValues[attr.name][0]) 
     519                val = self.attrValues[attr.name][0] + oldCondition[pos] * ( 
     520                self.attrValues[attr.name][1] - self.attrValues[attr.name][0]) 
    481521                strVal = attr.name + "= %%.%df" % (attr.numberOfDecimals) % (val) 
    482522                QToolTip.showText(e.globalPos(), strVal) 
     
    503543            x = self.invTransform(QwtPlot.xBottom, canvasPos.x()) 
    504544            y = self.invTransform(QwtPlot.yLeft, canvasPos.y()) 
    505             diffX = (self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue() -  self.axisScaleDiv(QwtPlot.xBottom).interval().minValue()) / 2. 
    506  
    507             xmin = x - (diffX/2.) * (x - self.axisScaleDiv(QwtPlot.xBottom).interval().minValue()) / diffX 
    508             xmax = x + (diffX/2.) * (self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue() - x) / diffX 
     545            diffX = (self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue() - self.axisScaleDiv( 
     546                QwtPlot.xBottom).interval().minValue()) / 2. 
     547 
     548            xmin = x - (diffX / 2.) * (x - self.axisScaleDiv(QwtPlot.xBottom).interval().minValue()) / diffX 
     549            xmax = x + (diffX / 2.) * (self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue() - x) / diffX 
    509550            ymin = self.axisScaleDiv(QwtPlot.yLeft).interval().maxValue() 
    510551            ymax = self.axisScaleDiv(QwtPlot.yLeft).interval().minValue() 
    511552 
    512             self.zoomStack.append((self.axisScaleDiv(QwtPlot.xBottom).interval().minValue(), self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue(), self.axisScaleDiv(QwtPlot.yLeft).interval().minValue(), self.axisScaleDiv(QwtPlot.yLeft).interval().maxValue())) 
     553            self.zoomStack.append((self.axisScaleDiv(QwtPlot.xBottom).interval().minValue(), 
     554                                   self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue(), 
     555                                   self.axisScaleDiv(QwtPlot.yLeft).interval().minValue(), 
     556                                   self.axisScaleDiv(QwtPlot.yLeft).interval().maxValue())) 
    513557            self.setNewZoom(xmin, xmax, ymax, ymin) 
    514558            return 1 
     
    518562            x1 = int(self.invTransform(QwtPlot.xBottom, e.x())) 
    519563            axis = self.axisScaleDraw(QwtPlot.xBottom) 
    520             self.parallelDlg.sendShownAttributes([str(axis.label(x1)), str(axis.label(x1+1))]) 
     564            self.parallelDlg.sendShownAttributes([str(axis.label(x1)), str(axis.label(x1 + 1))]) 
    521565        return 0 
    522566 
    523     def removeAllSelections(self, send = 1): 
     567    def removeAllSelections(self, send=1): 
    524568        self.selectionConditions = {} 
    525         self.updateData(self.visualizedAttributes, self.visualizedMidLabels, updateAxisScale = 0) 
     569        self.updateData(self.visualizedAttributes, self.visualizedMidLabels, updateAxisScale=0) 
    526570        if send and self.autoSendSelectionCallback: 
    527571            self.autoSendSelectionCallback() # do we want to send new selection 
     
    530574    def drawCanvas(self, painter): 
    531575        OWGraph.drawCanvas(self, painter) 
    532         for i in range(int(max(0, math.floor(self.axisScaleDiv(QwtPlot.xBottom).interval().minValue()))), int(min(len(self.visualizedAttributes), math.ceil(self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue())+1))): 
     576        for i in range(int(max(0, math.floor(self.axisScaleDiv(QwtPlot.xBottom).interval().minValue()))), int( 
     577                min(len(self.visualizedAttributes), 
     578                    math.ceil(self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue()) + 1))): 
    533579            bottom, top = self.selectionConditions.get(self.visualizedAttributes[i], (0, 1)) 
    534             painter.drawPixmap(self.transform(QwtPlot.xBottom, i)-self.bottomPixmap.width()/2, self.transform(QwtPlot.yLeft, bottom), self.bottomPixmap) 
    535             painter.drawPixmap(self.transform(QwtPlot.xBottom, i)-self.topPixmap.width()/2, self.transform(QwtPlot.yLeft, top)-self.topPixmap.height(), self.topPixmap) 
     580            painter.drawPixmap(self.transform(QwtPlot.xBottom, i) - self.bottomPixmap.width() / 2, 
     581                               self.transform(QwtPlot.yLeft, bottom), self.bottomPixmap) 
     582            painter.drawPixmap(self.transform(QwtPlot.xBottom, i) - self.topPixmap.width() / 2, 
     583                               self.transform(QwtPlot.yLeft, top) - self.topPixmap.height(), self.topPixmap) 
    536584 
    537585    # get selected examples 
     
    549597 
    550598 
    551  
    552599# #################################################################### 
    553600# a curve that is able to draw several series of lines 
    554601class ParallelCoordinatesCurve(QwtPlotCurve): 
    555     def __init__(self, attrCount, yData, color, name = ""): 
     602    def __init__(self, attrCount, yData, color, name=""): 
    556603        QwtPlotCurve.__init__(self, name) 
    557604        self.setStyle(QwtPlotCurve.Lines) 
     
    562609        self.xData = range(attrCount) * lineCount 
    563610        self.yData = yData 
    564          
    565 #        self._cubic = self.cubicPath(None, None) 
    566          
    567         self.setData(QPolygonF(map(lambda t:QPointF(*t), zip(self.xData, self.yData)))) 
     611 
     612        #        self._cubic = self.cubicPath(None, None) 
     613 
     614        self.setData(QPolygonF(map(lambda t: QPointF(*t), zip(self.xData, self.yData)))) 
    568615        if type(color) == tuple: 
    569616            self.setPen(QPen(QColor(*color))) 
     
    574621    def drawCurve(self, painter, style, xMap, yMap, iFrom, iTo): 
    575622        low = max(0, int(math.floor(xMap.s1()))) 
    576         high = min(self.attrCount-1, int(math.ceil(xMap.s2()))) 
     623        high = min(self.attrCount - 1, int(math.ceil(xMap.s2()))) 
    577624        painter.setPen(self.pen()) 
    578625        if not self.testCurveAttribute(QwtPlotCurve.Fitted): 
    579626            for i in range(self.dataSize() / self.attrCount): 
    580627                start = self.attrCount * i + low 
    581                 end = self.attrCount * i + high  
     628                end = self.attrCount * i + high 
    582629                self.drawLines(painter, xMap, yMap, start, end) 
    583630        else: 
    584631            painter.save() 
    585 #            painter.scale(xMap.transform(1.0), yMap.transform(1.0)) 
     632            #            painter.scale(xMap.transform(1.0), yMap.transform(1.0)) 
    586633            painter.strokePath(self.cubicPath(xMap, yMap), self.pen()) 
    587 #            painter.strokePath(self._cubic, self.pen()) 
     634            #            painter.strokePath(self._cubic, self.pen()) 
    588635            painter.restore() 
    589636 
     
    591638        path = QPainterPath() 
    592639        transform = lambda x, y: QPointF(xMap.transform(x), yMap.transform(y)) 
    593 #        transform = lambda x, y: QPointF(x, y) 
    594 #        data = [QPointF(transform(x, y)) for x, y in zip(self.xData, self.yData)] 
     640        #        transform = lambda x, y: QPointF(x, y) 
     641        #        data = [QPointF(transform(x, y)) for x, y in zip(self.xData, self.yData)] 
    595642        data = [(x, y) for x, y in zip(self.xData, self.yData)] 
    596643        for i in range(self.dataSize() / self.attrCount): 
    597             segment = data[i*self.attrCount: (i + 1)*self.attrCount] 
     644            segment = data[i * self.attrCount: (i + 1) * self.attrCount] 
    598645            for i, p in enumerate(segment[:-1]): 
    599646                x1, y1 = p 
Note: See TracChangeset for help on using the changeset viewer.