qwt_scale_map.cpp

Go to the documentation of this file.

/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 * Copyright (C) 2002   Uwe Rathmann
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the Qwt License, Version 1.0
 *****************************************************************************/

#include "qwt_scale_map.h"

QT_STATIC_CONST_IMPL double QwtScaleMap::LogMin = 1.0e-150;
QT_STATIC_CONST_IMPL double QwtScaleMap::LogMax = 1.0e150;

QwtScaleTransformation::QwtScaleTransformation(Type type):
    d_type(type)
{
}

QwtScaleTransformation::~QwtScaleTransformation()
{
}

QwtScaleTransformation *QwtScaleTransformation::copy() const
{
    return new QwtScaleTransformation(d_type);
}

double QwtScaleTransformation::xForm(
    double s, double s1, double s2, double p1, double p2) const
{
    if ( d_type == Log10 )  
        return p1 + (p2 - p1) / log(s2 / s1) * log(s / s1);
    else 
        return p1 + (p2 - p1) / (s2 - s1) * (s - s1);
}

double QwtScaleTransformation::invXForm(double p, double p1, double p2, 
    double s1, double s2) const
{
    if ( d_type == Log10 )  
        return exp((p - p1) / (p2 - p1) * log(s2 / s1)) * s1;
    else
        return s1 + (s2 - s1) / (p2 - p1) * (p - p1);
}

QwtScaleMap::QwtScaleMap():
    d_s1(0.0),
    d_s2(1.0),
    d_p1(0.0),
    d_p2(1.0),
    d_cnv(1.0)
{
    d_transformation = new QwtScaleTransformation(
        QwtScaleTransformation::Linear);
}

QwtScaleMap::QwtScaleMap(const QwtScaleMap& other):
    d_s1(other.d_s1),
    d_s2(other.d_s2),
    d_p1(other.d_p1),
    d_p2(other.d_p2),
    d_cnv(other.d_cnv)
{
    d_transformation = other.d_transformation->copy();
}

QwtScaleMap::~QwtScaleMap()
{
    delete d_transformation;
}

QwtScaleMap &QwtScaleMap::operator=(const QwtScaleMap &other)
{
    d_s1 = other.d_s1;
    d_s2 = other.d_s2;
    d_p1 = other.d_p1;
    d_p2 = other.d_p2;
    d_cnv = other.d_cnv;

    delete d_transformation;
    d_transformation = other.d_transformation->copy();

    return *this;
}

void QwtScaleMap::setTransformation(
    QwtScaleTransformation *transformation)
{
    if ( transformation == NULL )
        return;

    delete d_transformation;
    d_transformation = transformation;
    setScaleInterval(d_s1, d_s2);
}

const QwtScaleTransformation *QwtScaleMap::transformation() const
{
    return d_transformation;
}

void QwtScaleMap::setScaleInterval(double s1, double s2)
{
    if (d_transformation->type() == QwtScaleTransformation::Log10 )
    {
        if (s1 < LogMin) 
           s1 = LogMin;
        else if (s1 > LogMax) 
           s1 = LogMax;
        
        if (s2 < LogMin) 
           s2 = LogMin;
        else if (s2 > LogMax) 
           s2 = LogMax;
    }

    d_s1 = s1;
    d_s2 = s2;

    if ( d_transformation->type() != QwtScaleTransformation::Other )
        newFactor();
}

void QwtScaleMap::setPaintInterval(int p1, int p2)
{
    d_p1 = p1;
    d_p2 = p2;

    if ( d_transformation->type() != QwtScaleTransformation::Other )
        newFactor();
}

void QwtScaleMap::setPaintXInterval(double p1, double p2)
{
    d_p1 = p1;
    d_p2 = p2;

    if ( d_transformation->type() != QwtScaleTransformation::Other )
        newFactor();
}

void QwtScaleMap::newFactor()
{
    d_cnv = 0.0;
#if 1
    if (d_s2 == d_s1)
        return;
#endif

    switch( d_transformation->type() )
    {
        case QwtScaleTransformation::Linear:
            d_cnv = (d_p2 - d_p1) / (d_s2 - d_s1); 
            break;
        case QwtScaleTransformation::Log10:
            d_cnv = (d_p2 - d_p1) / log(d_s2 / d_s1);
            break;
        default:;
    }
}