Fixed and added support for QwtLogScaleEngine (<=> QwtLog10ScaleEngine in Qwt5)

Author: Pierre Raybaut

qwt/__init__.py

@@ -3,7 +3,7 @@
 
 from qwt.qwt_plot import QwtPlot
 from qwt.qwt_symbol import QwtSymbol
-from qwt.qwt_scale_engine import QwtLinearScaleEngine
+from qwt.qwt_scale_engine import QwtLinearScaleEngine, QwtLogScaleEngine
 from qwt.qwt_text import QwtText
 from qwt.qwt_plot_canvas import QwtPlotCanvas
 from qwt.qwt_plot_curve import QwtPlotCurve, QwtPlotItem
@@ -27,8 +27,6 @@
 QwtDoubleInterval = QwtInterval
 
 # to be implemented:
-# QwtLog10ScaleEngine, QwtPlotPrintFilter
-class QwtLog10ScaleEngine(object):
-    pass
+# QwtPlotPrintFilter
 class QwtPlotPrintFilter(object):
     pass

qwt/qwt_point_mapper.py

@@ -100,8 +100,8 @@ def qwtToPointsFiltered(boundingRect, xMap, yMap, series, from_, to,
     points = []
     for i in range(from_, to+1):
         sample = series.sample(i)
-        x = round(xMap.transform(sample.x()))
-        y = round(yMap.transform(sample.y()))
+        x = int(round(xMap.transform(sample.x())))
+        y = int(round(yMap.transform(sample.y())))
         points.append(Point(x, y))
     return Polygon(list(set(points)))
 

qwt/qwt_scale_draw.py

@@ -10,7 +10,7 @@
 from qwt.qt.QtCore import (Qt, qFuzzyCompare, QLocale, QRectF, QPointF, QRect,
                            QPoint)
 
-from math import ceil, sin, pi, cos
+import numpy as np
 
 
 class QwtAbstractScaleDraw_PrivateData(object):
@@ -233,8 +233,8 @@ def getBorderDistHint(self, font):
                 maxTick = tick
                 maxPos = tickPos
 
-        e = 0.
         s = 0.
+        e = 0.
         if self.orientation() == Qt.Vertical:
             s = -self.labelRect(font, minTick).top()
             s -= abs(minPos - round(self.scaleMap().p2()))
@@ -248,13 +248,7 @@ def getBorderDistHint(self, font):
             e = self.labelRect(font, maxTick).right()
             e -= abs(maxPos - self.scaleMap().p2())
 
-        if s < 0.:
-            s = 0.
-        if e < 0.:
-            e = 0.
-        
-        start = ceil(s)
-        end = ceil(e)
+        start, end = np.ceil(np.nan_to_num(np.array([s, e])).clip(0, None))
         return start, end
 
     def minLabelDist(self, font):
@@ -294,15 +288,15 @@ def minLabelDist(self, font):
 
         angle = qwtRadians(self.labelRotation())
         if vertical:
-            angle += pi/2
+            angle += np.pi/2
 
-        sinA = sin(angle)
+        sinA = np.sin(angle)
         if qFuzzyCompare(sinA+1., 1.):
-            return ceil(maxDist)
+            return np.ceil(maxDist)
 
         fmHeight = fm.ascent()-2
 
-        labelDist = fmHeight/sin(angle)*cos(angle)
+        labelDist = fmHeight/np.sin(angle)*np.cos(angle)
         if labelDist < 0:
             labelDist = -labelDist
 
@@ -312,7 +306,7 @@ def minLabelDist(self, font):
         if labelDist < fmHeight:
             labelDist = fmHeight
 
-        return ceil(labelDist)
+        return np.ceil(labelDist)
 
     def extent(self, font):
         d = 0.
@@ -342,7 +336,7 @@ def minLength(self, font):
         lengthForTicks = 0
         if self.hasComponent(QwtAbstractScaleDraw.Ticks):
             pw = max([1, self.penWidth()])
-            lengthForTicks = ceil((majorCount+minorCount)*(pw+1.))
+            lengthForTicks = np.ceil((majorCount+minorCount)*(pw+1.))
         return startDist + endDist + max([lengthForLabels, lengthForTicks])
 
     def labelPosition(self, value):
@@ -553,15 +547,15 @@ def maxLabelWidth(self, font):
         ticks = self.scaleDiv().ticks(QwtScaleDiv.MajorTick)
         if not ticks:
             return 0
-        return ceil(max([self.labelSize(font, v).width()
-                         for v in ticks if self.scaleDiv().contains(v)]))
+        return np.ceil(max([self.labelSize(font, v).width()
+                            for v in ticks if self.scaleDiv().contains(v)]))
 
     def maxLabelHeight(self, font):
         ticks = self.scaleDiv().ticks(QwtScaleDiv.MajorTick)
         if not ticks:
             return 0
-        return ceil(max([self.labelSize(font, v).height()
-                         for v in ticks if self.scaleDiv().contains(v)]))
+        return np.ceil(max([self.labelSize(font, v).height()
+                            for v in ticks if self.scaleDiv().contains(v)]))
 
     def updateMap(self):
         pos = self.__data.pos

qwt/qwt_scale_engine.py

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 
+from __future__ import division
+
 from qwt.qwt_interval import QwtInterval
 from qwt.qwt_scale_div import QwtScaleDiv
 from qwt.qwt_transform import QwtLogTransform
@@ -251,7 +253,7 @@ def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
         if numTicks % 2:
             medIndex = numTicks/2
         for val in ticks[QwtScaleDiv.MajorTick]:
-            for k in range(int(numTicks)):
+            for k in range(numTicks):
                 val += minStep
                 alignedValue = val
                 if qwtFuzzyCompare(val, 0., stepSize) == 0:
@@ -305,7 +307,7 @@ def autoScale(self, maxNumSteps, x1, x2, stepSize):
                     stepSize = qwtLog(logBase, stepSize)
                 return x1, x2, stepSize
 
-        logRef = -1.
+        logRef = 1.
         if self.reference() > LOG_MIN/2:
             logRef = min([self.reference(), LOG_MAX/2])
 
@@ -315,7 +317,9 @@ def autoScale(self, maxNumSteps, x1, x2, stepSize):
             interval.setInterval(logRef/delta, logRef*delta)
 
         if self.testAttribute(QwtScaleEngine.IncludeReference):
-            interval = interval.limited(LOG_MIN, LOG_MAX)
+            interval = interval.extend(logRef)
+
+        interval = interval.limited(LOG_MIN, LOG_MAX)        
 
         if interval.width() == 0.:
             interval = self.buildInterval(interval.minValue())
@@ -391,7 +395,7 @@ def buildTicks(self, interval, stepSize, maxMinorSteps):
 
     def buildMajorTicks(self, interval, stepSize):
         width = qwtLogInterval(self.base(), interval).width()
-        numTicks = min([round(width/stepSize)+1, 10000])
+        numTicks = min([int(round(width/stepSize))+1, 10000])
 
         lxmin = np.log(interval.minValue())
         lxmax = np.log(interval.maxValue())
@@ -411,7 +415,7 @@ def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
             if minStep == 0.:
                 return
 
-            numSteps = round(stepSize/minStep)
+            numSteps = int(round(stepSize/minStep))
 
             mediumTickIndex = -1
             if numSteps > 2 and numSteps % 2 == 0:
@@ -425,7 +429,7 @@ def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
                     for j in range(2, numSteps):
                         ticks[QwtScaleDiv.MinorTick] += [v*j*s]
                 else:
-                    for j in range(2, numSteps):
+                    for j in range(1, numSteps):
                         tick = v + j*v*(logBase-1)/numSteps
                         if j == mediumTickIndex:
                             ticks[QwtScaleDiv.MediumTick] += [tick]
@@ -440,7 +444,7 @@ def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
             if minStep < 1.:
                 minStep = 1.
 
-            numTicks = round(stepSize/minStep)-1
+            numTicks = int(round(stepSize/minStep))-1
 
             if qwtFuzzyCompare((numTicks+1)*minStep, stepSize, stepSize) > 0:
                 numTicks = 0
@@ -465,7 +469,7 @@ def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
     def align(self, interval, stepSize):
         intv = qwtLogInterval(self.base(), interval)
 
-        x1 = floorEps(intv.maxValue(), stepSize)
+        x1 = floorEps(intv.minValue(), stepSize)
         if qwtFuzzyCompare(interval.minValue(), x1, stepSize) == 0:
             x1 = interval.minValue()
 

qwt/qwt_transform.py

@@ -35,7 +35,7 @@ class QwtLogTransform(QwtTransform):
     LogMin = 1.0e-150
     LogMax = 1.0e150
     def bounded(self, value):
-        return max([self.LogMin, min([value, self.LogMax])])
+        return np.clip(value, self.LogMin, self.LogMax)
 
     def transform(self, value):
         return np.log(value)