Added QwtPlot.validAxes class attribute

This is an optimization: when plot methods are called several times,
using QwtPlot.validAxes instead of range(QwtPlot.axisCnt) will gain
precious milliseconds.

Author: PierreRaybaut

qwt/plot.py

@@ -277,7 +277,8 @@ class QwtPlot(QFrame, QwtPlotDict):
     legendDataChanged = Signal("PyQt_PyObject", "PyQt_PyObject")
 
     # enum Axis
-    yLeft, yRight, xBottom, xTop, axisCnt = list(range(5))
+    validAxes = yLeft, yRight, xBottom, xTop = list(range(4))
+    axisCnt = len(validAxes)
 
     # enum LegendPosition
     LeftLegend, RightLegend, BottomLegend, TopLegend = list(range(4))
@@ -363,7 +364,7 @@ def __del__(self):
 
     def initAxesData(self):
         """Initialize axes"""
-        self.__axisData = [AxisData() for axisId in range(self.axisCnt)]
+        self.__axisData = [AxisData() for axisId in self.validAxes]
 
         self.__axisData[self.yLeft].scaleWidget = \
             QwtScaleWidget(QwtScaleDraw.LeftScale, self)
@@ -386,7 +387,7 @@ def initAxesData(self):
         fscl = QFont(self.fontInfo().family(), 10)
         fttl = QFont(self.fontInfo().family(), 12, QFont.Bold)
 
-        for axisId in range(self.axisCnt):
+        for axisId in self.validAxes:
             d = self.__axisData[axisId]
 
             d.scaleEngine = QwtLinearScaleEngine()
@@ -414,7 +415,7 @@ def initAxesData(self):
 
     def deleteAxesData(self):
         #XXX Is is really necessary in Python? (pure transcription of C++)
-        for axisId in range(self.axisCnt):
+        for axisId in self.validAxes:
             self.__axisData[axisId].scaleEngine = None
             self.__axisData[axisId] = None
 
@@ -851,7 +852,7 @@ def updateAxes(self):
             :py:meth:`setAxisScaleDiv()`, :py:meth:`replot()`,
             :py:meth:`QwtPlotItem.boundingRect()`
         """
-        intv = [QwtInterval() for _i in range(self.axisCnt)]
+        intv = [QwtInterval() for _i in self.validAxes]
         itmList = self.itemList()
         for item in itmList:
             if not item.testItemAttribute(QwtPlotItem.AutoScale):
@@ -864,7 +865,7 @@ def updateAxes(self):
                     intv[item.xAxis()] |= QwtInterval(rect.left(), rect.right())
                 if rect.height() >= 0.:
                     intv[item.yAxis()] |= QwtInterval(rect.top(), rect.bottom())
-        for axisId in range(self.axisCnt):
+        for axisId in self.validAxes:
             d = self.__axisData[axisId]
             minValue = d.minValue
             maxValue = d.maxValue
@@ -1084,7 +1085,7 @@ def sizeHint(self):
             :py:meth:`minimumSizeHint()`
         """
         dw = dh = 0
-        for axisId in range(self.axisCnt):
+        for axisId in self.validAxes:
             if self.axisEnabled(axisId):
                 niceDist = 40
                 scaleWidget = self.axisWidget(axisId)
@@ -1145,7 +1146,7 @@ def get_layout_state(self):
         return (self.contentsRect(),
                 self.__data.titleLabel.text(), self.__data.footerLabel.text(),
                 [(self.axisEnabled(axisId), self.axisTitle(axisId).text())
-                 for axisId in range(self.axisCnt)],
+                 for axisId in self.validAxes],
                 self.__data.legend)
 
     def updateLayout(self):
@@ -1166,9 +1167,8 @@ def updateLayout(self):
 
         titleRect = self.__data.layout.titleRect().toRect()
         footerRect = self.__data.layout.footerRect().toRect()
-        scaleRect = [None] * self.axisCnt
-        for axisId in range(self.axisCnt):
-            scaleRect[axisId] = self.__data.layout.scaleRect(axisId).toRect()
+        scaleRect = [self.__data.layout.scaleRect(axisId).toRect()
+                     for axisId in self.validAxes]
         legendRect = self.__data.layout.legendRect().toRect()
         canvasRect = self.__data.layout.canvasRect().toRect()
 
@@ -1186,7 +1186,7 @@ def updateLayout(self):
         else:
             self.__data.footerLabel.hide()
 
-        for axisId in range(self.axisCnt):
+        for axisId in self.validAxes:
             if self.axisEnabled(axisId):
                 self.axisWidget(axisId).setGeometry(scaleRect[axisId])
 
@@ -1254,12 +1254,12 @@ def updateCanvasMargins(self):
             :py:meth:`getCanvasMarginsHint()`, 
             :py:meth:`QwtPlotItem.getCanvasMarginHint()`
         """
-        maps = [self.canvasMap(axisId) for axisId in range(self.axisCnt)]
+        maps = [self.canvasMap(axisId) for axisId in self.validAxes]
         margins = self.getCanvasMarginsHint(maps, self.canvas().contentsRect())
 
         doUpdate = False
 
-        for axisId in range(self.axisCnt):
+        for axisId in self.validAxes:
             if margins[axisId] >= 0.:
                 m = np.ceil(margins[axisId])
                 self.plotLayout().setCanvasMargin(m, axisId)
@@ -1285,7 +1285,7 @@ def drawCanvas(self, painter):
             :py:meth:`getCanvasMarginsHint()`, 
             :py:meth:`QwtPlotItem.getCanvasMarginHint()`
         """
-        maps = [self.canvasMap(axisId) for axisId in range(self.axisCnt)]
+        maps = [self.canvasMap(axisId) for axisId in self.validAxes]
         self.drawItems(painter, self.__data.canvas.contentsRect(), maps)
 
     def drawItems(self, painter, canvasRect, maps):
@@ -1397,7 +1397,7 @@ def axisValid(self, axisId):
         :param int axisId: Axis
         :return: True if the specified axis exists, otherwise False
         """
-        return axisId in range(QwtPlot.axisCnt)
+        return axisId in QwtPlot.validAxes
 
     def insertLegend(self, legend, pos=None, ratio=-1):
         """

qwt/plot_layout.py

@@ -56,14 +56,14 @@ def __init__(self):
 
 class CanvasData(object):
     def __init__(self):
-        self.contentsMargins = [0 for _i in range(QwtPlot.axisCnt)]
+        self.contentsMargins = [0 for _i in QwtPlot.validAxes]
 
 class QwtPlotLayout_LayoutData(object):
     def __init__(self):
         self.legend = LegendData()
         self.title = TitleData()
         self.footer = FooterData()
-        self.scale = [ScaleData() for _i in range(QwtPlot.axisCnt)]
+        self.scale = [ScaleData() for _i in QwtPlot.validAxes]
         self.canvas = CanvasData()
 
     def init(self, plot, rect):
@@ -100,7 +100,7 @@ def init(self, plot, rect):
                 self.footer.text.setFont(label.font())
             self.footer.frameWidth = plot.footerLabel().frameWidth()
         # scales
-        for axis in range(QwtPlot.axisCnt):
+        for axis in QwtPlot.validAxes:
             if plot.axisEnabled(axis):
                 scaleWidget = plot.axisWidget(axis)
                 self.scale[axis].isEnabled = True
@@ -133,7 +133,7 @@ def __init__(self):
         self.titleRect = QRectF()
         self.footerRect = QRectF()
         self.legendRect = QRectF()
-        self.scaleRect = [QRectF() for _i in range(QwtPlot.axisCnt)]
+        self.scaleRect = [QRectF() for _i in QwtPlot.validAxes]
         self.canvasRect = QRectF()
         self.layoutData = QwtPlotLayout_LayoutData()
         self.legendPos = None
@@ -199,9 +199,9 @@ def setCanvasMargin(self, margin, axis=-1):
         if margin < 1:
             margin = -1
         if axis == -1:
-            for axis in range(QwtPlot.axisCnt):
+            for axis in QwtPlot.validAxes:
                 self.__data.canvasMargin[axis] = margin
-        elif axis >= 0 and axis < QwtPlot.axisCnt:
+        elif axis in QwtPlot.validAxes:
             self.__data.canvasMargin[axis] = margin
 
     def canvasMargin(self, axisId):
@@ -213,7 +213,7 @@ def canvasMargin(self, axisId):
         
             :py:meth:`setCanvasMargin()`
         """
-        if axisId < 0 or axisId >= QwtPlot.axisCnt:
+        if axisId not in QwtPlot.validAxes:
             return 0
         return self.__data.canvasMargin[axisId]
 
@@ -250,11 +250,11 @@ def setAlignCanvasToScales(self, *args):
         """
         if len(args) == 1:
             on, = args
-            for axis in range(QwtPlot.axisCnt):
+            for axis in QwtPlot.validAxes:
                 self.__data.alignCanvasToScales[axis] = on
         elif len(args) == 2:
             axisId, on = args
-            if axis >= 0 and axis < QwtPlot.axisCnt:
+            if axis in QwtPlot.validAxes:
                 self.__data.alignCanvasToScales[axisId] = on
         else:
             raise TypeError("%s().setAlignCanvasToScales() takes 1 or 2 "\
@@ -276,7 +276,7 @@ def alignCanvasToScale(self, axisId):
         
             :py:meth:`setAlignCanvasToScale()`, :py:meth:`setCanvasMargin()`
         """
-        if axisId < 0 or axisId >= QwtPlot.axisCnt:
+        if axisId not in QwtPlot.validAxes:
             return False
         return self.__data.alignCanvasToScales[axisId]
 
@@ -477,7 +477,7 @@ def setScaleRect(self, axis, rect):
         
             :py:meth:`scaleRect()`, :py:meth:`activate()`
         """
-        if axis >= 0 and axis < QwtPlot.axisCnt:
+        if axis in QwtPlot.validAxes:
             self.__data.scaleRect[axis] = rect
 
     def scaleRect(self, axis):
@@ -489,7 +489,7 @@ def scaleRect(self, axis):
         
             :py:meth:`invalidate()`, :py:meth:`activate()`
         """
-        if axis < 0 or axis >= QwtPlot.axisCnt:
+        if axis not in QwtPlot.validAxes:
             return QRectF()
         return self.__data.scaleRect[axis]
 
@@ -530,7 +530,7 @@ def invalidate(self):
         self.__data.footerRect = QRectF()
         self.__data.legendRect = QRectF()
         self.__data.canvasRect = QRectF()
-        for axis in range(QwtPlot.axisCnt):
+        for axis in QwtPlot.validAxes:
             self.__data.scaleRect[axis] = QRectF()
 
     def minimumSizeHint(self, plot):
@@ -549,10 +549,10 @@ def __init__(self):
                 self.minLeft = 0
                 self.minRight = 0
                 self.tickOffset = 0
-        scaleData = [_ScaleData() for _i in range(QwtPlot.axisCnt)]
-        canvasBorder = [0 for _i in range(QwtPlot.axisCnt)]
+        scaleData = [_ScaleData() for _i in QwtPlot.validAxes]
+        canvasBorder = [0 for _i in QwtPlot.validAxes]
         fw, _, _, _ = plot.canvas().getContentsMargins()
-        for axis in range(QwtPlot.axisCnt):
+        for axis in QwtPlot.validAxes:
             if plot.axisEnabled(axis):
                 scl = plot.axisWidget(axis)
                 sd = scaleData[axis]
@@ -564,7 +564,7 @@ def __init__(self):
                 if scl.scaleDraw().hasComponent(QwtAbstractScaleDraw.Ticks):
                     sd.tickOffset += np.ceil(scl.scaleDraw().maxTickLength())
             canvasBorder[axis] = fw + self.__data.canvasMargin[axis] + 1
-        for axis in range(QwtPlot.axisCnt):
+        for axis in QwtPlot.validAxes:
             sd = scaleData[axis]
             if sd.w and axis in (QwtPlot.xBottom, QwtPlot.xTop):
                 if sd.minLeft > canvasBorder[QwtPlot.yLeft]\
@@ -707,9 +707,9 @@ def expandLineBreaks(self, options, rect):
             * `dimAxis`: Expanded heights of the axis in axis orientation.
         """
         dimTitle = dimFooter = 0
-        dimAxis = [0 for axis in range(QwtPlot.axisCnt)]
-        backboneOffset = [0 for _i in range(QwtPlot.axisCnt)]
-        for axis in range(QwtPlot.axisCnt):
+        dimAxis = [0 for axis in QwtPlot.validAxes]
+        backboneOffset = [0 for _i in QwtPlot.validAxes]
+        for axis in QwtPlot.validAxes:
             if not (options & self.IgnoreFrames):
                 backboneOffset[axis] += self.__data.layoutData.canvas.contentsMargins[axis]
             if not self.__data.alignCanvasToScales[axis]:
@@ -748,7 +748,7 @@ def expandLineBreaks(self, options, rect):
                 if d > dimFooter:
                     dimFooter = d
                     done = False
-            for axis in range(QwtPlot.axisCnt):
+            for axis in QwtPlot.validAxes:
                 scaleData = self.__data.layoutData.scale[axis]
                 if scaleData.isEnabled:
                     if axis in (QwtPlot.xTop, QwtPlot.xBottom):
@@ -793,14 +793,14 @@ def alignScales(self, options, canvasRect, scaleRect):
         :param QRectF canvasRect: Geometry of the canvas ( IN/OUT )
         :param QRectF scaleRect: Geometry of the scales ( IN/OUT )
         """
-        backboneOffset = [0 for _i in range(QwtPlot.axisCnt)]
-        for axis in range(QwtPlot.axisCnt):
+        backboneOffset = [0 for _i in QwtPlot.validAxes]
+        for axis in QwtPlot.validAxes:
             backboneOffset[axis] = 0
             if not self.__data.alignCanvasToScales[axis]:
                 backboneOffset[axis] += self.__data.canvasMargin[axis]
             if not options & self.IgnoreFrames:
                 backboneOffset[axis] += self.__data.layoutData.canvas.contentsMargins[axis]
-        for axis in range(QwtPlot.axisCnt):
+        for axis in QwtPlot.validAxes:
             if not scaleRect[axis].isValid():
                 continue
             startDist = self.__data.layoutData.scale[axis].start
@@ -881,7 +881,7 @@ def alignScales(self, options, canvasRect, scaleRect):
                     else:
                         if topOffset > 0:
                             axisRect.setTop(axisRect.top()+topOffset)
-        for axis in range(QwtPlot.axisCnt):
+        for axis in QwtPlot.validAxes:
             sRect = scaleRect[axis]
             if not sRect.isValid():
                 continue
@@ -990,7 +990,7 @@ def activate(self, plot, plotRect, options=0x00):
                 rect.y()+dimAxes[QwtPlot.xTop],
                 rect.width()-dimAxes[QwtPlot.yRight]-dimAxes[QwtPlot.yLeft],
                 rect.height()-dimAxes[QwtPlot.xBottom]-dimAxes[QwtPlot.xTop])
-        for axis in range(QwtPlot.axisCnt):
+        for axis in QwtPlot.validAxes:
             if dimAxes[axis]:
                 dim = dimAxes[axis]
                 scaleRect = self.__data.scaleRect[axis]

qwt/plot_renderer.py

@@ -348,7 +348,7 @@ def render(self, plot, painter, plotRect):
         baseLineDists = [None]*QwtPlot.axisCnt
         canvasMargins = [None]*QwtPlot.axisCnt
 
-        for axisId in range(QwtPlot.axisCnt):
+        for axisId in QwtPlot.validAxes:
             canvasMargins[axisId] = layout.canvasMargin(axisId)
             if self.__data.layoutFlags & self.FrameWithScales:
                 scaleWidget = plot.axisWidget(axisId)
@@ -410,7 +410,7 @@ def render(self, plot, painter, plotRect):
            plot.titleLabel().text():
             self.renderLegend(plot, painter, layout.legendRect())
 
-        for axisId in range(QwtPlot.axisCnt):
+        for axisId in QwtPlot.validAxes:
             scaleWidget = plot.axisWidget(axisId)
             if scaleWidget:
                 baseDist = scaleWidget.margin()
@@ -420,7 +420,7 @@ def render(self, plot, painter, plotRect):
 
         painter.restore()
 
-        for axisId in range(QwtPlot.axisCnt):
+        for axisId in QwtPlot.validAxes:
             if self.__data.layoutFlags & self.FrameWithScales:
                 scaleWidget = plot.axisWidget(axisId)
                 if scaleWidget:
@@ -603,7 +603,7 @@ def buildCanvasMaps(self, plot, canvasRect):
         :return: Calculated scale maps
         """
         maps = []
-        for axisId in range(QwtPlot.axisCnt):
+        for axisId in QwtPlot.validAxes:
             map_ = QwtScaleMap()
             map_.setTransformation(
                                 plot.axisScaleEngine(axisId).transformation())
@@ -635,7 +635,7 @@ def buildCanvasMaps(self, plot, canvasRect):
     def updateCanvasMargins(self, plot, canvasRect, maps):
         margins = plot.getCanvasMarginsHint(maps, canvasRect)
         marginsChanged = False
-        for axisId in range(QwtPlot.axisCnt):
+        for axisId in QwtPlot.validAxes:
             if margins[axisId] >= 0.:
                 m = np.ceil(margins[axisId])
                 plot.plotLayout().setCanvasMargin(m, axisId)