You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
298 lines
7.8 KiB
298 lines
7.8 KiB
/* -*- 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 <qnumeric.h> |
|
#include <qmath.h> |
|
|
|
class QwtMatrixRasterData::PrivateData |
|
{ |
|
public: |
|
PrivateData(): |
|
resampleMode(QwtMatrixRasterData::NearestNeighbour), |
|
numColumns(0) |
|
{ |
|
} |
|
|
|
inline double value(int row, int col) const |
|
{ |
|
return values.data()[ row * numColumns + col ]; |
|
} |
|
|
|
QwtMatrixRasterData::ResampleMode resampleMode; |
|
|
|
QVector<double> values; |
|
int numColumns; |
|
int numRows; |
|
|
|
double dx; |
|
double dy; |
|
}; |
|
|
|
//! Constructor |
|
QwtMatrixRasterData::QwtMatrixRasterData() |
|
{ |
|
d_data = new PrivateData(); |
|
update(); |
|
} |
|
|
|
//! Destructor |
|
QwtMatrixRasterData::~QwtMatrixRasterData() |
|
{ |
|
delete d_data; |
|
} |
|
|
|
/*! |
|
\brief Set the resampling algorithm |
|
|
|
\param mode Resampling mode |
|
\sa resampleMode(), value() |
|
*/ |
|
void QwtMatrixRasterData::setResampleMode( ResampleMode mode ) |
|
{ |
|
d_data->resampleMode = mode; |
|
} |
|
|
|
/*! |
|
\return resampling algorithm |
|
\sa setResampleMode(), value() |
|
*/ |
|
QwtMatrixRasterData::ResampleMode QwtMatrixRasterData::resampleMode() const |
|
{ |
|
return d_data->resampleMode; |
|
} |
|
|
|
/*! |
|
\brief Assign the bounding interval for an axis |
|
|
|
Setting the bounding intervals for the X/Y axis is mandatory |
|
to define the positions for the values of the value matrix. |
|
The interval in Z direction defines the possible range for |
|
the values in the matrix, what is f.e used by QwtPlotSpectrogram |
|
to map values to colors. The Z-interval might be the bounding |
|
interval of the values in the matrix, but usually it isn't. |
|
( f.e a interval of 0.0-100.0 for values in percentage ) |
|
|
|
\param axis X, Y or Z axis |
|
\param interval Interval |
|
|
|
\sa QwtRasterData::interval(), setValueMatrix() |
|
*/ |
|
void QwtMatrixRasterData::setInterval( |
|
Qt::Axis axis, const QwtInterval &interval ) |
|
{ |
|
QwtRasterData::setInterval( axis, interval ); |
|
update(); |
|
} |
|
|
|
/*! |
|
\brief Assign a value matrix |
|
|
|
The positions of the values are calculated by dividing |
|
the bounding rectangle of the X/Y intervals into equidistant |
|
rectangles ( pixels ). Each value corresponds to the center of |
|
a pixel. |
|
|
|
\param values Vector of values |
|
\param numColumns Number of columns |
|
|
|
\sa valueMatrix(), numColumns(), numRows(), setInterval()() |
|
*/ |
|
void QwtMatrixRasterData::setValueMatrix( |
|
const QVector<double> &values, int numColumns ) |
|
{ |
|
d_data->values = values; |
|
d_data->numColumns = qMax( numColumns, 0 ); |
|
update(); |
|
} |
|
|
|
/*! |
|
\return Value matrix |
|
\sa setValueMatrix(), numColumns(), numRows(), setInterval() |
|
*/ |
|
const QVector<double> QwtMatrixRasterData::valueMatrix() const |
|
{ |
|
return d_data->values; |
|
} |
|
|
|
/*! |
|
\brief Change a single value in the matrix |
|
|
|
\param row Row index |
|
\param col Column index |
|
\param value New value |
|
|
|
\sa value(), setValueMatrix() |
|
*/ |
|
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; |
|
} |
|
} |
|
|
|
/*! |
|
\return Number of columns of the value matrix |
|
\sa valueMatrix(), numRows(), setValueMatrix() |
|
*/ |
|
int QwtMatrixRasterData::numColumns() const |
|
{ |
|
return d_data->numColumns; |
|
} |
|
|
|
/*! |
|
\return Number of rows of the value matrix |
|
\sa valueMatrix(), numColumns(), setValueMatrix() |
|
*/ |
|
int QwtMatrixRasterData::numRows() const |
|
{ |
|
return d_data->numRows; |
|
} |
|
|
|
/*! |
|
\brief Calculate the pixel hint |
|
|
|
pixelHint() returns the geometry of a pixel, that can be used |
|
to calculate the resolution and alignment of the plot item, that is |
|
representing the data. |
|
|
|
- NearestNeighbour\n |
|
pixelHint() returns the surrounding pixel of the top left value |
|
in the matrix. |
|
|
|
- BilinearInterpolation\n |
|
Returns an empty rectangle recommending |
|
to render in target device ( f.e. screen ) resolution. |
|
|
|
\param area Requested area, ignored |
|
\return Calculated hint |
|
|
|
\sa ResampleMode, setMatrix(), setInterval() |
|
*/ |
|
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; |
|
} |
|
|
|
/*! |
|
\return the value at a raster position |
|
|
|
\param x X value in plot coordinates |
|
\param y Y value in plot coordinates |
|
|
|
\sa ResampleMode |
|
*/ |
|
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 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 >= static_cast<int>( d_data->numColumns ) ) |
|
col2 = col1; |
|
|
|
if ( row1 < 0 ) |
|
row1 = row2; |
|
else if ( row2 >= static_cast<int>( 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; |
|
} |
|
}
|
|
|