Changeset 8127 in ntrip for trunk/BNC/qwt/qwt_scale_engine.cpp

Timestamp:

May 10, 2017, 3:20:54 PM (7 years ago)

Author:

stoecker

Message:

update qwt and qwtpolar, many QT5 fixes (unfinished)

File:

• trunk/BNC/qwt/qwt_scale_engine.cpp (modified) (42 diffs)

trunk/BNC/qwt/qwt_scale_engine.cpp

@@ -13 +13 @@
 #include <qalgorithms.h>
 #include <qmath.h>
+#include <float.h>
+#include <limits>
 
 #if QT_VERSION < 0x040601
@@ -19 +21 @@
 #endif
 
+static inline double qwtLog( double base, double value )
+{
+    return log( value ) / log( base );
+}
+
+static inline QwtInterval qwtLogInterval( double base, const QwtInterval &interval )
+{
+    return QwtInterval( qwtLog( base, interval.minValue() ),
+            qwtLog( base, interval.maxValue() ) );
+}
+
+static inline QwtInterval qwtPowInterval( double base, const QwtInterval &interval ) 
+{
+    return QwtInterval( qPow( base, interval.minValue() ),
+            qPow( base, interval.maxValue() ) );
+}
+
+static inline long double qwtIntervalWidthL( const QwtInterval &interval )
+{
+    if ( !interval.isValid() )
+        return 0.0;
+
+    return static_cast<long double>( interval.maxValue() )
+        - static_cast<long double>( interval.minValue() );
+}
+
+#if 1
+
+// this version often doesn't find the best ticks: f.e for 15: 5, 10
+static double qwtStepSize( double intervalSize, int maxSteps, uint base )
+{
+    const double minStep = 
+        QwtScaleArithmetic::divideInterval( intervalSize, maxSteps, base );
+
+    if ( minStep != 0.0 )
+    {
+        // # ticks per interval
+        const int numTicks = qCeil( qAbs( intervalSize / minStep ) ) - 1;
+
+        // Do the minor steps fit into the interval?
+        if ( qwtFuzzyCompare( ( numTicks +  1 ) * qAbs( minStep ),
+            qAbs( intervalSize ), intervalSize ) > 0 )
+        {
+            // The minor steps doesn't fit into the interval
+            return 0.5 * intervalSize;
+        }
+    }
+
+    return minStep;
+}
+
+#else
+
+static double qwtStepSize( double intervalSize, int maxSteps, uint base )
+{
+    if ( maxSteps <= 0 )
+        return 0.0;
+
+    if ( maxSteps > 2 )
+    {
+        for ( int numSteps = maxSteps; numSteps > 1; numSteps-- )
+        {
+            const double stepSize = intervalSize / numSteps;
+
+            const double p = ::floor( ::log( stepSize ) / ::log( base ) );
+            const double fraction = qPow( base, p );
+
+            for ( uint n = base; n > 1; n /= 2 )
+            {
+                if ( qFuzzyCompare( stepSize, n * fraction ) )
+                    return stepSize;
+
+                if ( n == 3 && ( base % 2 ) == 0 )
+                {
+                    if ( qFuzzyCompare( stepSize, 2 * fraction ) )
+                        return stepSize;
+                }
+            }
+        }
+    }
+
+    return intervalSize * 0.5;
+}
+
+#endif
+
 static const double _eps = 1.0e-6;
 
@@ -24 +112 @@
   Ceil a value, relative to an interval
 
-  \param value Value to ceil
+  \param value Value to be ceiled
   \param intervalSize Interval size
+
+  \return Rounded value
 
   \sa floorEps()
@@ -35 +125 @@
 
     value = ( value - eps ) / intervalSize;
-    return qwtCeilF( value ) * intervalSize;
+    return ::ceil( value ) * intervalSize;
 }
 
@@ -41 +131 @@
   Floor a value, relative to an interval
 
-  \param value Value to floor
+  \param value Value to be floored
   \param intervalSize Interval size
 
+  \return Rounded value
   \sa floorEps()
 */
@@ -51 +142 @@
 
     value = ( value + eps ) / intervalSize;
-    return qwtFloorF( value ) * intervalSize;
+    return ::floor( value ) * intervalSize;
 }
 
@@ -72 +163 @@
 
 /*!
-  Find the smallest value out of {1,2,5}*10^n with an integer number n
-  which is greater than or equal to x
-
-  \param x Input value
-*/
-double QwtScaleArithmetic::ceil125( double x )
-{
-    if ( x == 0.0 )
+  Calculate a step size for a given interval
+
+  \param intervalSize Interval size
+  \param numSteps Number of steps
+  \param base Base for the division ( usually 10 )
+
+  \return Calculated step size
+ */
+double QwtScaleArithmetic::divideInterval( 
+    double intervalSize, int numSteps, uint base ) 
+{
+    if ( numSteps <= 0 )
         return 0.0;
 
-    const double sign = ( x > 0 ) ? 1.0 : -1.0;
-    const double lx = ::log10( qFabs( x ) );
-    const double p10 = qwtFloorF( lx );
-
-    double fr = qPow( 10.0, lx - p10 );
-    if ( fr <= 1.0 )
-        fr = 1.0;
-    else if ( fr <= 2.0 )
-        fr = 2.0;
-    else if ( fr <= 5.0 )
-        fr = 5.0;
-    else
-        fr = 10.0;
-
-    return sign * fr * qPow( 10.0, p10 );
-}
-
-/*!
-  \brief Find the largest value out of {1,2,5}*10^n with an integer number n
-  which is smaller than or equal to x
-
-  \param x Input value
-*/
-double QwtScaleArithmetic::floor125( double x )
-{
-    if ( x == 0.0 )
+    const double v = QwtScaleArithmetic::divideEps( intervalSize, numSteps );
+    if ( v == 0.0 )
         return 0.0;
 
-    double sign = ( x > 0 ) ? 1.0 : -1.0;
-    const double lx = ::log10( qFabs( x ) );
-    const double p10 = qwtFloorF( lx );
-
-    double fr = qPow( 10.0, lx - p10 );
-    if ( fr >= 10.0 )
-        fr = 10.0;
-    else if ( fr >= 5.0 )
-        fr = 5.0;
-    else if ( fr >= 2.0 )
-        fr = 2.0;
-    else
-        fr = 1.0;
-
-    return sign * fr * qPow( 10.0, p10 );
+    const double lx = qwtLog( base, qFabs( v ) );
+    const double p = ::floor( lx );
+
+    const double fraction = qPow( base, lx - p );
+
+    uint n = base;
+    while ( ( n > 1 ) && ( fraction <= n / 2 ) )
+        n /= 2;
+
+    double stepSize = n * qPow( base, p );
+    if ( v < 0 )
+        stepSize = -stepSize;
+
+    return stepSize;
 }
 
@@ -134 +204 @@
         lowerMargin( 0.0 ),
         upperMargin( 0.0 ),
-        referenceValue( 0.0 )
-    {
-    }
-
-    QwtScaleEngine::Attributes attributes;       // scale attributes
-
-    double lowerMargin;      // margins
+        referenceValue( 0.0 ),
+        base( 10 ),
+        transform( NULL )
+    {
+    }
+
+    ~PrivateData()
+    {
+        delete transform;
+    }
+
+    QwtScaleEngine::Attributes attributes;
+
+    double lowerMargin;
     double upperMargin;
 
-    double referenceValue; // reference value
-
+    double referenceValue;
+
+    uint base;
+
+    QwtTransform* transform;
 };
 
-//! Constructor
-QwtScaleEngine::QwtScaleEngine()
+/*!
+  Constructor
+
+  \param base Base of the scale engine
+  \sa setBase()
+ */
+QwtScaleEngine::QwtScaleEngine( uint base )
 {
     d_data = new PrivateData;
+    setBase( base );
 }
 
@@ -158 +244 @@
 {
     delete d_data;
+}
+
+/*!
+   Assign a transformation
+
+   \param transform Transformation
+
+   The transformation object is used as factory for clones
+   that are returned by transformation()
+
+   The scale engine takes ownership of the transformation.
+
+   \sa QwtTransform::copy(), transformation()
+
+ */
+void QwtScaleEngine::setTransformation( QwtTransform *transform )
+{
+    if ( transform != d_data->transform )
+    {
+        delete d_data->transform;
+        d_data->transform = transform;
+    }
+}
+
+/*!
+   Create and return a clone of the transformation 
+   of the engine. When the engine has no special transformation
+   NULL is returned, indicating no transformation.
+
+   \return A clone of the transfomation
+   \sa setTransformation()
+ */
+QwtTransform *QwtScaleEngine::transformation() const
+{
+    QwtTransform *transform = NULL;
+    if ( d_data->transform )
+        transform = d_data->transform->copy();
+
+    return transform;
 }
 
@@ -193 +318 @@
 
   \warning
-  \li QwtLog10ScaleEngine measures the margins in decades.
+  \li QwtLogScaleEngine measures the margins in decades.
 
   \sa upperMargin(), lowerMargin()
@@ -215 +340 @@
     double intervalSize, int numSteps ) const
 {
-    if ( numSteps <= 0 )
-        return 0.0;
-
-    double v = QwtScaleArithmetic::divideEps( intervalSize, numSteps );
-    return QwtScaleArithmetic::ceil125( v );
+    return QwtScaleArithmetic::divideInterval( 
+        intervalSize, numSteps, d_data->base );
 }
 
@@ -228 +350 @@
   \param value Value
 
-  \sa QwtScaleArithmetic::compareEps()
+  \return True, when the value is inside the interval
 */
 bool QwtScaleEngine::contains(
@@ -275 +397 @@
 
 /*!
-  \brief Build an interval for a value
+  \brief Build an interval around a value
 
   In case of v == 0.0 the interval is [-0.5, 0.5],
   otherwide it is [0.5 * v, 1.5 * v]
-*/
-
-QwtInterval QwtScaleEngine::buildInterval( double v ) const
-{
-    const double delta = ( v == 0.0 ) ? 0.5 : qAbs( 0.5 * v );
-    return QwtInterval( v - delta, v + delta );
+
+  \param value Initial value
+  \return Calculated interval
+*/
+
+QwtInterval QwtScaleEngine::buildInterval( double value ) const
+{
+    const double delta = ( value == 0.0 ) ? 0.5 : qAbs( 0.5 * value );
+
+    if ( DBL_MAX - delta < value )
+        return QwtInterval( DBL_MAX - delta, DBL_MAX );
+
+    if ( -DBL_MAX + delta > value )
+        return QwtInterval( -DBL_MAX, -DBL_MAX + delta );
+
+    return QwtInterval( value - delta, value + delta );
 }
 
@@ -304 +436 @@
 
 /*!
-  Check if a attribute is set.
+  \return True, if attribute is enabled.
 
   \param attribute Attribute to be tested
@@ -326 +458 @@
 
 /*!
-  Return the scale attributes
+  \return Scale attributes
   \sa Attribute, setAttributes(), testAttribute()
 */
@@ -349 +481 @@
 
 /*!
- \return the reference value
- \sa setReference(), setAttribute()
+  \return the reference value
+  \sa setReference(), setAttribute()
 */
 double QwtScaleEngine::reference() const
@@ -358 +490 @@
 
 /*!
-  Return a transformation, for linear scales
-*/
-QwtScaleTransformation *QwtLinearScaleEngine::transformation() const
-{
-    return new QwtScaleTransformation( QwtScaleTransformation::Linear );
-}
-
-/*!
-    Align and divide an interval
-
-   \param maxNumSteps Max. number of steps
-   \param x1 First limit of the interval (In/Out)
-   \param x2 Second limit of the interval (In/Out)
-   \param stepSize Step size (Out)
-
-   \sa setAttribute()
+  Set the base of the scale engine
+
+  While a base of 10 is what 99.9% of all applications need
+  certain scales might need a different base: f.e 2
+
+  The default setting is 10
+
+  \param base Base of the engine
+
+  \sa base()
+ */
+void QwtScaleEngine::setBase( uint base )
+{ 
+    d_data->base = qMax( base, 2U );
+}
+
+/*!
+  \return base Base of the scale engine
+  \sa setBase()
+ */
+uint QwtScaleEngine::base() const
+{
+    return d_data->base;
+}
+
+/*!
+  Constructor
+
+  \param base Base of the scale engine
+  \sa setBase()
+ */
+QwtLinearScaleEngine::QwtLinearScaleEngine( uint base ):
+    QwtScaleEngine( base )
+{
+}
+
+//! Destructor
+QwtLinearScaleEngine::~QwtLinearScaleEngine()
+{
+}
+
+/*!
+  Align and divide an interval
+
+  \param maxNumSteps Max. number of steps
+  \param x1 First limit of the interval (In/Out)
+  \param x2 Second limit of the interval (In/Out)
+  \param stepSize Step size (Out)
+
+  \sa setAttribute()
 */
 void QwtLinearScaleEngine::autoScale( int maxNumSteps,
@@ -393 +559 @@
         interval = buildInterval( interval.minValue() );
 
-    stepSize = divideInterval( interval.width(), qMax( maxNumSteps, 1 ) );
+    stepSize = QwtScaleArithmetic::divideInterval( 
+        interval.width(), qMax( maxNumSteps, 1 ), base() );
 
     if ( !testAttribute( QwtScaleEngine::Floating ) )
@@ -409 +576 @@
 
 /*!
-   \brief Calculate a scale division
+   \brief Calculate a scale division for an interval
 
    \param x1 First interval limit
    \param x2 Second interval limit
-   \param maxMajSteps Maximum for the number of major steps
-   \param maxMinSteps Maximum number of minor steps
-   \param stepSize Step size. If stepSize == 0, the scaleEngine
+   \param maxMajorSteps Maximum for the number of major steps
+   \param maxMinorSteps Maximum number of minor steps
+   \param stepSize Step size. If stepSize == 0, the engine
                    calculates one.
 
-   \sa QwtScaleEngine::stepSize(), QwtScaleEngine::subDivide()
+   \return Calculated scale division
 */
 QwtScaleDiv QwtLinearScaleEngine::divideScale( double x1, double x2,
-    int maxMajSteps, int maxMinSteps, double stepSize ) const
+    int maxMajorSteps, int maxMinorSteps, double stepSize ) const
 {
     QwtInterval interval = QwtInterval( x1, x2 ).normalized();
+
+    if ( qwtIntervalWidthL( interval ) > std::numeric_limits<double>::max() )
+    {
+        qWarning() << "QwtLinearScaleEngine::divideScale: overflow";
+        return QwtScaleDiv();
+    }
+
     if ( interval.width() <= 0 )
         return QwtScaleDiv();
@@ -430 +604 @@
     if ( stepSize == 0.0 )
     {
-        if ( maxMajSteps < 1 )
-            maxMajSteps = 1;
-
-        stepSize = divideInterval( interval.width(), maxMajSteps );
+        if ( maxMajorSteps < 1 )
+            maxMajorSteps = 1;
+
+        stepSize = QwtScaleArithmetic::divideInterval( 
+            interval.width(), maxMajorSteps, base() );
     }
 
@@ -441 +616 @@
     {
         QList<double> ticks[QwtScaleDiv::NTickTypes];
-        buildTicks( interval, stepSize, maxMinSteps, ticks );
+        buildTicks( interval, stepSize, maxMinorSteps, ticks );
 
         scaleDiv = QwtScaleDiv( interval, ticks );
@@ -457 +632 @@
    \param interval Interval
    \param stepSize Step size
-   \param maxMinSteps Maximum number of minor steps
+   \param maxMinorSteps Maximum number of minor steps
    \param ticks Arrays to be filled with the calculated ticks
 
@@ -463 +638 @@
 */
 void QwtLinearScaleEngine::buildTicks(
-    const QwtInterval& interval, double stepSize, int maxMinSteps,
+    const QwtInterval& interval, double stepSize, int maxMinorSteps,
     QList<double> ticks[QwtScaleDiv::NTickTypes] ) const
 {
-    const QwtInterval boundingInterval =
-        align( interval, stepSize );
+    const QwtInterval boundingInterval = align( interval, stepSize );
 
     ticks[QwtScaleDiv::MajorTick] =
         buildMajorTicks( boundingInterval, stepSize );
 
-    if ( maxMinSteps > 0 )
-    {
-        buildMinorTicks( ticks[QwtScaleDiv::MajorTick], maxMinSteps, stepSize,
+    if ( maxMinorSteps > 0 )
+    {
+        buildMinorTicks( ticks[QwtScaleDiv::MajorTick], maxMinorSteps, stepSize,
             ticks[QwtScaleDiv::MinorTick], ticks[QwtScaleDiv::MediumTick] );
     }
@@ -522 +696 @@
 
    \param majorTicks Major ticks
-   \param maxMinSteps Maximum number of minor steps
+   \param maxMinorSteps Maximum number of minor steps
    \param stepSize Step size
    \param minorTicks Array to be filled with the calculated minor ticks
@@ -530 +704 @@
 void QwtLinearScaleEngine::buildMinorTicks(
     const QList<double>& majorTicks,
-    int maxMinSteps, double stepSize,
+    int maxMinorSteps, double stepSize,
     QList<double> &minorTicks,
     QList<double> &mediumTicks ) const
 {
-    double minStep = divideInterval( stepSize, maxMinSteps );
+    double minStep = qwtStepSize( stepSize, maxMinorSteps, base() );
     if ( minStep == 0.0 )
         return;
 
     // # ticks per interval
-    int numTicks = qCeil( qAbs( stepSize / minStep ) ) - 1;
-
-    // Do the minor steps fit into the interval?
-    if ( qwtFuzzyCompare( ( numTicks +  1 ) * qAbs( minStep ),
-        qAbs( stepSize ), stepSize ) > 0 )
-    {
-        numTicks = 1;
-        minStep = stepSize * 0.5;
-    }
+    const int numTicks = qCeil( qAbs( stepSize / minStep ) ) - 1;
 
     int medIndex = -1;
@@ -588 +754 @@
     const QwtInterval &interval, double stepSize ) const
 {
-    double x1 = QwtScaleArithmetic::floorEps( interval.minValue(), stepSize );
-    if ( qwtFuzzyCompare( interval.minValue(), x1, stepSize ) == 0 )
-        x1 = interval.minValue();
-
-    double x2 = QwtScaleArithmetic::ceilEps( interval.maxValue(), stepSize );
-    if ( qwtFuzzyCompare( interval.maxValue(), x2, stepSize ) == 0 )
-        x2 = interval.maxValue();
+    double x1 = interval.minValue();
+    double x2 = interval.maxValue();
+
+    // when there is no rounding beside some effect, when 
+    // calculating with doubles, we keep the original value
+
+    const double eps = 0.000000000001; // since Qt 4.8: qFuzzyIsNull
+    if ( -DBL_MAX + stepSize <= x1 )
+    {
+        const double x = QwtScaleArithmetic::floorEps( x1, stepSize );
+        if ( qAbs(x) <= eps || !qFuzzyCompare( x1, x ) )
+            x1 = x;
+    }
+
+    if ( DBL_MAX - stepSize >= x2 )
+    {
+        const double x = QwtScaleArithmetic::ceilEps( x2, stepSize );
+        if ( qAbs(x) <= eps || !qFuzzyCompare( x2, x ) )
+            x2 = x;
+    }
 
     return QwtInterval( x1, x2 );
@@ -600 +779 @@
 
 /*!
-  Return a transformation, for logarithmic (base 10) scales
-*/
-QwtScaleTransformation *QwtLog10ScaleEngine::transformation() const
-{
-    return new QwtScaleTransformation( QwtScaleTransformation::Log10 );
+  Constructor
+
+  \param base Base of the scale engine
+  \sa setBase()
+ */
+QwtLogScaleEngine::QwtLogScaleEngine( uint base ):
+    QwtScaleEngine( base )
+{
+    setTransformation( new QwtLogTransform() );
+}
+
+//! Destructor
+QwtLogScaleEngine::~QwtLogScaleEngine()
+{
 }
 
@@ -617 +805 @@
    \sa QwtScaleEngine::setAttribute()
 */
-void QwtLog10ScaleEngine::autoScale( int maxNumSteps,
-                                     double &x1, double &x2, double &stepSize ) const
+void QwtLogScaleEngine::autoScale( int maxNumSteps,
+    double &x1, double &x2, double &stepSize ) const
 {
     if ( x1 > x2 )
         qSwap( x1, x2 );
 
-    QwtInterval interval( x1 / qPow( 10.0, lowerMargin() ),
-        x2 * qPow( 10.0, upperMargin() ) );
-
-    if ( interval.maxValue() / interval.minValue() < 10.0 )
-    {
-        // scale width is less than one decade -> build linear scale
+    const double logBase = base();
+
+    QwtInterval interval( x1 / qPow( logBase, lowerMargin() ),
+        x2 * qPow( logBase, upperMargin() ) );
+
+    if ( interval.maxValue() / interval.minValue() < logBase )
+    {
+        // scale width is less than one step -> try to build a linear scale
 
         QwtLinearScaleEngine linearScaler;
@@ -636 +826 @@
 
         linearScaler.autoScale( maxNumSteps, x1, x2, stepSize );
-        stepSize = ::log10( stepSize );
-
-        return;
+
+        QwtInterval linearInterval = QwtInterval( x1, x2 ).normalized();
+        linearInterval = linearInterval.limited( LOG_MIN, LOG_MAX );
+
+        if ( linearInterval.maxValue() / linearInterval.minValue() < logBase )
+        {
+            // the aligned scale is still less than one step
+
+#if 1
+            // this code doesn't make any sense, but for compatibility
+            // reasons we keep it until 6.2. But it will be ignored
+            // in divideScale
+
+            if ( stepSize < 0.0 )
+                stepSize = -qwtLog( logBase, qAbs( stepSize ) );
+            else
+                stepSize = qwtLog( logBase, stepSize );
+#endif
+
+            return;
+        }
     }
 
@@ -660 +868 @@
         interval = buildInterval( interval.minValue() );
 
-    stepSize = divideInterval( log10( interval ).width(), qMax( maxNumSteps, 1 ) );
+    stepSize = divideInterval( qwtLogInterval( logBase, interval ).width(), 
+        qMax( maxNumSteps, 1 ) );
     if ( stepSize < 1.0 )
         stepSize = 1.0;
@@ -678 +887 @@
 
 /*!
-   \brief Calculate a scale division
+   \brief Calculate a scale division for an interval
 
    \param x1 First interval limit
    \param x2 Second interval limit
-   \param maxMajSteps Maximum for the number of major steps
-   \param maxMinSteps Maximum number of minor steps
-   \param stepSize Step size. If stepSize == 0, the scaleEngine
+   \param maxMajorSteps Maximum for the number of major steps
+   \param maxMinorSteps Maximum number of minor steps
+   \param stepSize Step size. If stepSize == 0, the engine
                    calculates one.
 
-   \sa QwtScaleEngine::stepSize(), QwtLog10ScaleEngine::subDivide()
-*/
-QwtScaleDiv QwtLog10ScaleEngine::divideScale( double x1, double x2,
-    int maxMajSteps, int maxMinSteps, double stepSize ) const
+   \return Calculated scale division
+*/
+QwtScaleDiv QwtLogScaleEngine::divideScale( double x1, double x2,
+    int maxMajorSteps, int maxMinorSteps, double stepSize ) const
 {
     QwtInterval interval = QwtInterval( x1, x2 ).normalized();
@@ -698 +907 @@
         return QwtScaleDiv();
 
-    if ( interval.maxValue() / interval.minValue() < 10.0 )
+    const double logBase = base();
+
+    if ( interval.maxValue() / interval.minValue() < logBase )
     {
         // scale width is less than one decade -> build linear scale
@@ -707 +918 @@
         linearScaler.setMargins( lowerMargin(), upperMargin() );
 
-        if ( stepSize != 0.0 )
-            stepSize = qPow( 10.0, stepSize );
-
         return linearScaler.divideScale( x1, x2,
-            maxMajSteps, maxMinSteps, stepSize );
+            maxMajorSteps, maxMinorSteps, 0.0 );
     }
 
@@ -717 +925 @@
     if ( stepSize == 0.0 )
     {
-        if ( maxMajSteps < 1 )
-            maxMajSteps = 1;
-
-        stepSize = divideInterval( log10( interval ).width(), maxMajSteps );
+        if ( maxMajorSteps < 1 )
+            maxMajorSteps = 1;
+
+        stepSize = divideInterval( 
+            qwtLogInterval( logBase, interval ).width(), maxMajorSteps );
         if ( stepSize < 1.0 )
             stepSize = 1.0; // major step must be >= 1 decade
@@ -729 +938 @@
     {
         QList<double> ticks[QwtScaleDiv::NTickTypes];
-        buildTicks( interval, stepSize, maxMinSteps, ticks );
+        buildTicks( interval, stepSize, maxMinorSteps, ticks );
 
         scaleDiv = QwtScaleDiv( interval, ticks );
@@ -744 +953 @@
 
    \param interval Interval
-   \param maxMinSteps Maximum number of minor steps
+   \param maxMinorSteps Maximum number of minor steps
    \param stepSize Step size
    \param ticks Arrays to be filled with the calculated ticks
@@ -750 +959 @@
    \sa buildMajorTicks(), buildMinorTicks
 */
-void QwtLog10ScaleEngine::buildTicks(
-    const QwtInterval& interval, double stepSize, int maxMinSteps,
+void QwtLogScaleEngine::buildTicks(
+    const QwtInterval& interval, double stepSize, int maxMinorSteps,
     QList<double> ticks[QwtScaleDiv::NTickTypes] ) const
 {
@@ -759 +968 @@
         buildMajorTicks( boundingInterval, stepSize );
 
-    if ( maxMinSteps > 0 )
-    {
-        ticks[QwtScaleDiv::MinorTick] = buildMinorTicks(
-            ticks[QwtScaleDiv::MajorTick], maxMinSteps, stepSize );
+    if ( maxMinorSteps > 0 )
+    {
+        buildMinorTicks( ticks[QwtScaleDiv::MajorTick], maxMinorSteps, stepSize,
+            ticks[QwtScaleDiv::MinorTick], ticks[QwtScaleDiv::MediumTick] );
     }
 
@@ -777 +986 @@
    \return Calculated ticks
 */
-QList<double> QwtLog10ScaleEngine::buildMajorTicks(
+QList<double> QwtLogScaleEngine::buildMajorTicks(
     const QwtInterval &interval, double stepSize ) const
 {
-    double width = log10( interval ).width();
+    double width = qwtLogInterval( base(), interval ).width();
 
     int numTicks = qRound( width / stepSize ) + 1;
@@ -806 +1015 @@
 
    \param majorTicks Major ticks
-   \param maxMinSteps Maximum number of minor steps
+   \param maxMinorSteps Maximum number of minor steps
    \param stepSize Step size
-*/
-QList<double> QwtLog10ScaleEngine::buildMinorTicks(
+   \param minorTicks Array to be filled with the calculated minor ticks
+   \param mediumTicks Array to be filled with the calculated medium ticks
+*/
+void QwtLogScaleEngine::buildMinorTicks(
     const QList<double> &majorTicks,
-    int maxMinSteps, double stepSize ) const
-{
-    if ( stepSize < 1.1 )          // major step width is one decade
-    {
-        if ( maxMinSteps < 1 )
-            return QList<double>();
-
-        int k0, kstep, kmax;
-
-        if ( maxMinSteps >= 8 )
+    int maxMinorSteps, double stepSize,
+    QList<double> &minorTicks,
+    QList<double> &mediumTicks ) const
+{
+    const double logBase = base();
+
+    if ( stepSize < 1.1 )          // major step width is one base
+    {
+        double minStep = divideInterval( stepSize, maxMinorSteps + 1 );
+        if ( minStep == 0.0 )
+            return;
+        
+        const int numSteps = qRound( stepSize / minStep ); 
+
+        int mediumTickIndex = -1;
+        if ( ( numSteps > 2 ) && ( numSteps % 2 == 0 ) )
+            mediumTickIndex = numSteps / 2;
+
+        for ( int i = 0; i < majorTicks.count() - 1; i++ )
         {
-            k0 = 2;
-            kmax = 9;
-            kstep = 1;
+            const double v = majorTicks[i];
+            const double s = logBase / numSteps;
+
+            if ( s >= 1.0 )
+            {
+                if ( !qFuzzyCompare( s, 1.0 ) )
+                    minorTicks += v * s;
+
+                for ( int j = 2; j < numSteps; j++ )
+                {
+                    minorTicks += v * j * s;
+                }
+            }
+            else
+            {
+                for ( int j = 1; j < numSteps; j++ )
+                {
+                    const double tick = v + j * v * ( logBase - 1 ) / numSteps;
+                    if ( j == mediumTickIndex )
+                        mediumTicks += tick;
+                    else
+                        minorTicks += tick;
+                }
+            }
         }
-        else if ( maxMinSteps >= 4 )
+    }
+    else
+    {
+        double minStep = divideInterval( stepSize, maxMinorSteps );
+        if ( minStep == 0.0 )
+            return;
+
+        if ( minStep < 1.0 )
+            minStep = 1.0;
+
+        // # subticks per interval
+        int numTicks = qRound( stepSize / minStep ) - 1;
+
+        // Do the minor steps fit into the interval?
+        if ( qwtFuzzyCompare( ( numTicks +  1 ) * minStep,
+            stepSize, stepSize ) > 0 )
         {
-            k0 = 2;
-            kmax = 8;
-            kstep = 2;
+            numTicks = 0;
         }
-        else if ( maxMinSteps >= 2 )
-        {
-            k0 = 2;
-            kmax = 5;
-            kstep = 3;
-        }
-        else
-        {
-            k0 = 5;
-            kmax = 5;
-            kstep = 1;
-        }
-
-        QList<double> minorTicks;
+
+        if ( numTicks < 1 )
+            return; 
+
+        int mediumTickIndex = -1;
+        if ( ( numTicks > 2 ) && ( numTicks % 2 ) )
+            mediumTickIndex = numTicks / 2;
+
+        // substep factor = base^substeps
+        const qreal minFactor = qMax( qPow( logBase, minStep ), qreal( logBase ) );
 
         for ( int i = 0; i < majorTicks.count(); i++ )
         {
-            const double v = majorTicks[i];
-            for ( int k = k0; k <= kmax; k += kstep )
-                minorTicks += v * double( k );
-        }
-
-        return minorTicks;
-    }
-    else  // major step > one decade
-    {
-        double minStep = divideInterval( stepSize, maxMinSteps );
-        if ( minStep == 0.0 )
-            return QList<double>();
-
-        if ( minStep < 1.0 )
-            minStep = 1.0;
-
-        // # subticks per interval
-        int nMin = qRound( stepSize / minStep ) - 1;
-
-        // Do the minor steps fit into the interval?
-
-        if ( qwtFuzzyCompare( ( nMin +  1 ) * minStep,
-            qAbs( stepSize ), stepSize ) > 0 )
-        {
-            nMin = 0;
-        }
-
-        if ( nMin < 1 )
-            return QList<double>();      // no subticks
-
-        // substep factor = 10^substeps
-        const qreal minFactor = qMax( qPow( 10.0, minStep ), qreal( 10.0 ) );
-
-        QList<double> minorTicks;
-        for ( int i = 0; i < majorTicks.count(); i++ )
-        {
-            double val = majorTicks[i];
-            for ( int k = 0; k < nMin; k++ )
+            double tick = majorTicks[i];
+            for ( int j = 0; j < numTicks; j++ )
             {
-                val *= minFactor;
-                minorTicks += val;
+                tick *= minFactor;
+
+                if ( j == mediumTickIndex )
+                    mediumTicks += tick;
+                else
+                    minorTicks += tick;
             }
         }
-        return minorTicks;
     }
 }
@@ -907 +1124 @@
   \return Aligned interval
 */
-QwtInterval QwtLog10ScaleEngine::align(
+QwtInterval QwtLogScaleEngine::align(
     const QwtInterval &interval, double stepSize ) const
 {
-    const QwtInterval intv = log10( interval );
+    const QwtInterval intv = qwtLogInterval( base(), interval );
 
     double x1 = QwtScaleArithmetic::floorEps( intv.minValue(), stepSize );
@@ -920 +1137 @@
         x2 = interval.maxValue();
 
-    return pow10( QwtInterval( x1, x2 ) );
-}
-
-/*!
-  Return the interval [log10(interval.minValue(), log10(interval.maxValue]
-*/
-
-QwtInterval QwtLog10ScaleEngine::log10( const QwtInterval &interval ) const
-{
-    return QwtInterval( ::log10( interval.minValue() ),
-            ::log10( interval.maxValue() ) );
-}
-
-/*!
-  Return the interval [pow10(interval.minValue(), pow10(interval.maxValue]
-*/
-QwtInterval QwtLog10ScaleEngine::pow10( const QwtInterval &interval ) const
-{
-    return QwtInterval( qPow( 10.0, interval.minValue() ),
-            qPow( 10.0, interval.maxValue() ) );
-}
+    return qwtPowInterval( base(), QwtInterval( x1, x2 ) );
+}