qwt_matrix_raster_data.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_matrix_raster_data.h"
#include "qwt_interval.h"

#include <qvector.h>
#include <qnumeric.h>
#include <qrect.h>

static inline double qwtHermiteInterpolate(
    double A, double B, double C, double D, double t )
{
    const double t2 = t * t;
    const double t3 = t2 * t;

    const double a = -A / 2.0 + ( 3.0 * B ) / 2.0 - ( 3.0 * C ) / 2.0 + D / 2.0;
    const double b = A - ( 5.0 * B ) / 2.0 + 2.0 * C - D / 2.0;
    const double c = -A / 2.0 + C / 2.0;
    const double d = B;

    return a * t3 + b * t2 + c * t + d;
}

static inline double qwtBicubicInterpolate(
    double v00, double v10, double v20, double v30,
    double v01, double v11, double v21, double v31, 
    double v02, double v12, double v22, double v32,
    double v03, double v13, double v23, double v33,
    double dx, double dy )
{
    const double v0 = qwtHermiteInterpolate( v00, v10, v20, v30, dx );
    const double v1 = qwtHermiteInterpolate( v01, v11, v21, v31, dx );
    const double v2 = qwtHermiteInterpolate( v02, v12, v22, v32, dx );
    const double v3 = qwtHermiteInterpolate( v03, v13, v23, v33, dx );

    return qwtHermiteInterpolate( v0, v1, v2, v3, dy );
}

class QwtMatrixRasterData::PrivateData
{
public:
    PrivateData():
        resampleMode(QwtMatrixRasterData::NearestNeighbour),
        numColumns(0)
    {
    }

    inline double value(int row, int col) const
    {
        return values.data()[ row * numColumns + col ];
    }

    QwtInterval intervals[3];
    QwtMatrixRasterData::ResampleMode resampleMode;

    QVector<double> values;
    int numColumns;
    int numRows;

    double dx;
    double dy;
};

QwtMatrixRasterData::QwtMatrixRasterData()
{
    d_data = new PrivateData();
    update();
}

QwtMatrixRasterData::~QwtMatrixRasterData()
{
    delete d_data;
}

void QwtMatrixRasterData::setResampleMode( ResampleMode mode )
{
    d_data->resampleMode = mode;
}

QwtMatrixRasterData::ResampleMode QwtMatrixRasterData::resampleMode() const
{
    return d_data->resampleMode;
}

void QwtMatrixRasterData::setInterval(
    Qt::Axis axis, const QwtInterval &interval )
{
    if ( axis >= 0 && axis <= 2 )
    {
        d_data->intervals[axis] = interval;
        update();
    }
}

QwtInterval QwtMatrixRasterData::interval( Qt::Axis axis ) const
{
    if ( axis >= 0 && axis <= 2 )
        return d_data->intervals[ axis ];

    return QwtInterval();
}

void QwtMatrixRasterData::setValueMatrix(
    const QVector<double> &values, int numColumns )
{
    d_data->values = values;
    d_data->numColumns = qMax( numColumns, 0 );
    update();
}

const QVector<double> QwtMatrixRasterData::valueMatrix() const
{
    return d_data->values;
}

void QwtMatrixRasterData::setValue( int row, int col, double value )
{
    if ( row >= 0 && row < d_data->numRows &&
        col >= 0 && col < d_data->numColumns )
    {
        const int index = row * d_data->numColumns + col;
        d_data->values.data()[ index ] = value;
    }
}

int QwtMatrixRasterData::numColumns() const
{
    return d_data->numColumns;
}

int QwtMatrixRasterData::numRows() const
{
    return d_data->numRows;
}

QRectF QwtMatrixRasterData::pixelHint( const QRectF &area ) const
{
    Q_UNUSED( area )

    QRectF rect;
    if ( d_data->resampleMode == NearestNeighbour )
    {
        const QwtInterval intervalX = interval( Qt::XAxis );
        const QwtInterval intervalY = interval( Qt::YAxis );
        if ( intervalX.isValid() && intervalY.isValid() )
        {
            rect = QRectF( intervalX.minValue(), intervalY.minValue(),
                d_data->dx, d_data->dy );
        }
    }

    return rect;
}

double QwtMatrixRasterData::value( double x, double y ) const
{
    const QwtInterval xInterval = interval( Qt::XAxis );
    const QwtInterval yInterval = interval( Qt::YAxis );

    if ( !( xInterval.contains(x) && yInterval.contains(y) ) )
        return qQNaN();

    double value;

    switch( d_data->resampleMode )
    {
        case BicubicInterpolation:
        {
            const double colF = ( x - xInterval.minValue() ) / d_data->dx;
            const double rowF = ( y - yInterval.minValue() ) / d_data->dy;

            const int col = qRound( colF );
            const int row = qRound( rowF );

            int col0 = col - 2;
            int col1 = col - 1;
            int col2 = col;
            int col3 = col + 1;

            if ( col1 < 0 )
                col1 = col2;

            if ( col0 < 0 )
                col0 = col1;

            if ( col2 >= d_data->numColumns )
                col2 = col1;

            if ( col3 >= d_data->numColumns )
                col3 = col2;

            int row0 = row - 2;
            int row1 = row - 1;
            int row2 = row;
            int row3 = row + 1;

            if ( row1 < 0 )
                row1 = row2;

            if ( row0 < 0 )
                row0 = row1;
            
            if ( row2 >= d_data->numRows )
                row2 = row1;
            
            if ( row3 >= d_data->numRows )
                row3 = row2;

            // First row
            const double v00 = d_data->value( row0, col0 );
            const double v10 = d_data->value( row0, col1 );
            const double v20 = d_data->value( row0, col2 );
            const double v30 = d_data->value( row0, col3 );

            // Second row
            const double v01 = d_data->value( row1, col0 );
            const double v11 = d_data->value( row1, col1 );
            const double v21 = d_data->value( row1, col2 );
            const double v31 = d_data->value( row1, col3 );

            // Third row
            const double v02 = d_data->value( row2, col0 );
            const double v12 = d_data->value( row2, col1 );
            const double v22 = d_data->value( row2, col2 );
            const double v32 = d_data->value( row2, col3 );

            // Fourth row
            const double v03 = d_data->value( row3, col0 );
            const double v13 = d_data->value( row3, col1 );
            const double v23 = d_data->value( row3, col2 );
            const double v33 = d_data->value( row3, col3 );

            value = qwtBicubicInterpolate(
                v00, v10, v20, v30, v01, v11, v21, v31,
                v02, v12, v22, v32, v03, v13, v23, v33,
                colF - col + 0.5, rowF - row + 0.5 );

            break;
        }
        case BilinearInterpolation:
        {
            int col1 = qRound( ( x - xInterval.minValue() ) / d_data->dx ) - 1;
            int row1 = qRound( ( y - yInterval.minValue() ) / d_data->dy ) - 1;
            int col2 = col1 + 1;
            int row2 = row1 + 1;

            if ( col1 < 0 )
                col1 = col2;
            else if ( col2 >= d_data->numColumns )
                col2 = col1;

            if ( row1 < 0 )
                row1 = row2;
            else if ( row2 >= d_data->numRows )
                row2 = row1;

            const double v11 = d_data->value( row1, col1 );
            const double v21 = d_data->value( row1, col2 );
            const double v12 = d_data->value( row2, col1 );
            const double v22 = d_data->value( row2, col2 );

            const double x2 = xInterval.minValue() + ( col2 + 0.5 ) * d_data->dx;
            const double y2 = yInterval.minValue() + ( row2 + 0.5 ) * d_data->dy;

            const double rx = ( x2 - x ) / d_data->dx;
            const double ry = ( y2 - y ) / d_data->dy;

            const double vr1 = rx * v11 + ( 1.0 - rx ) * v21;
            const double vr2 = rx * v12 + ( 1.0 - rx ) * v22;

            value = ry * vr1 + ( 1.0 - ry ) * vr2;

            break;
        }
        case NearestNeighbour:
        default:
        {
            int row = int( ( y - yInterval.minValue() ) / d_data->dy );
            int col = int( ( x - xInterval.minValue() ) / d_data->dx );

            // In case of intervals, where the maximum is included
            // we get out of bound for row/col, when the value for the
            // maximum is requested. Instead we return the value
            // from the last row/col

            if ( row >= d_data->numRows )
                row = d_data->numRows - 1;

            if ( col >= d_data->numColumns )
                col = d_data->numColumns - 1;

            value = d_data->value( row, col );
        }
    }

    return value;
}

void QwtMatrixRasterData::update()
{
    d_data->numRows = 0;
    d_data->dx = 0.0;
    d_data->dy = 0.0;

    if ( d_data->numColumns > 0 )
    {
        d_data->numRows = d_data->values.size() / d_data->numColumns;

        const QwtInterval xInterval = interval( Qt::XAxis );
        const QwtInterval yInterval = interval( Qt::YAxis );
        if ( xInterval.isValid() )
            d_data->dx = xInterval.width() / d_data->numColumns;
        if ( yInterval.isValid() )
            d_data->dy = yInterval.width() / d_data->numRows;
    }
}