10 #include "qwt_matrix_raster_data.h" 
   11 #include "qwt_interval.h" 
   17 static inline double qwtHermiteInterpolate(
 
   18     double A, 
double B, 
double C, 
double D, 
double t )
 
   20     const double t2 = t * t;
 
   21     const double t3 = t2 * t;
 
   23     const double a = -A / 2.0 + ( 3.0 * B ) / 2.0 - ( 3.0 * C ) / 2.0 + D / 2.0;
 
   24     const double b = A - ( 5.0 * B ) / 2.0 + 2.0 * C - D / 2.0;
 
   25     const double c = -A / 2.0 + C / 2.0;
 
   28     return a * t3 + b * t2 + c * t + d;
 
   31 static inline double qwtBicubicInterpolate(
 
   32     double v00, 
double v10, 
double v20, 
double v30,
 
   33     double v01, 
double v11, 
double v21, 
double v31,
 
   34     double v02, 
double v12, 
double v22, 
double v32,
 
   35     double v03, 
double v13, 
double v23, 
double v33,
 
   36     double dx, 
double dy )
 
   38     const double v0 = qwtHermiteInterpolate( v00, v10, v20, v30, dx );
 
   39     const double v1 = qwtHermiteInterpolate( v01, v11, v21, v31, dx );
 
   40     const double v2 = qwtHermiteInterpolate( v02, v12, v22, v32, dx );
 
   41     const double v3 = qwtHermiteInterpolate( v03, v13, v23, v33, dx );
 
   43     return qwtHermiteInterpolate( v0, v1, v2, v3, dy );
 
   46 class QwtMatrixRasterData::PrivateData
 
   55     inline double value(
int row, 
int col)
 const 
   57         return values.data()[ row * 
numColumns + col ];
 
   74     m_data = 
new PrivateData();
 
   92     m_data->resampleMode = mode;
 
  101     return m_data->resampleMode;
 
  123     if ( axis >= 0 && axis <= 2 )
 
  136     if ( axis >= 0 && axis <= 2 )
 
  137         return m_data->intervals[ axis ];
 
  158     m_data->values = values;
 
  169     return m_data->values;
 
  183     if ( row >= 0 && row < m_data->
numRows &&
 
  186         const int index = row * m_data->numColumns + col;
 
  187         m_data->values.data()[ index ] = 
value;
 
  197     return m_data->numColumns;
 
  206     return m_data->numRows;
 
  241                 m_data->dx, m_data->dy );
 
  266     switch( m_data->resampleMode )
 
  270             const double colF = ( x - xInterval.
minValue() ) / m_data->dx;
 
  271             const double rowF = ( y - yInterval.
minValue() ) / m_data->dy;
 
  273             const int col = qRound( colF );
 
  274             const int row = qRound( rowF );
 
  287             if ( col2 >= m_data->numColumns )
 
  290             if ( col3 >= m_data->numColumns )
 
  304             if ( row2 >= m_data->numRows )
 
  307             if ( row3 >= m_data->numRows )
 
  311             const double v00 = m_data->value( row0, col0 );
 
  312             const double v10 = m_data->value( row0, col1 );
 
  313             const double v20 = m_data->value( row0, col2 );
 
  314             const double v30 = m_data->value( row0, col3 );
 
  317             const double v01 = m_data->value( row1, col0 );
 
  318             const double v11 = m_data->value( row1, col1 );
 
  319             const double v21 = m_data->value( row1, col2 );
 
  320             const double v31 = m_data->value( row1, col3 );
 
  323             const double v02 = m_data->value( row2, col0 );
 
  324             const double v12 = m_data->value( row2, col1 );
 
  325             const double v22 = m_data->value( row2, col2 );
 
  326             const double v32 = m_data->value( row2, col3 );
 
  329             const double v03 = m_data->value( row3, col0 );
 
  330             const double v13 = m_data->value( row3, col1 );
 
  331             const double v23 = m_data->value( row3, col2 );
 
  332             const double v33 = m_data->value( row3, col3 );
 
  334             value = qwtBicubicInterpolate(
 
  335                 v00, v10, v20, v30, v01, v11, v21, v31,
 
  336                 v02, v12, v22, v32, v03, v13, v23, v33,
 
  337                 colF - col + 0.5, rowF - row + 0.5 );
 
  343             int col1 = qRound( ( x - xInterval.
minValue() ) / m_data->dx ) - 1;
 
  344             int row1 = qRound( ( y - yInterval.
minValue() ) / m_data->dy ) - 1;
 
  350             else if ( col2 >= m_data->numColumns )
 
  355             else if ( row2 >= m_data->numRows )
 
  358             const double v11 = m_data->value( row1, col1 );
 
  359             const double v21 = m_data->value( row1, col2 );
 
  360             const double v12 = m_data->value( row2, col1 );
 
  361             const double v22 = m_data->value( row2, col2 );
 
  363             const double x2 = xInterval.
minValue() + ( col2 + 0.5 ) * m_data->dx;
 
  364             const double y2 = yInterval.
minValue() + ( row2 + 0.5 ) * m_data->dy;
 
  366             const double rx = ( x2 - x ) / m_data->dx;
 
  367             const double ry = ( y2 - y ) / m_data->dy;
 
  369             const double vr1 = rx * v11 + ( 1.0 - rx ) * v21;
 
  370             const double vr2 = rx * v12 + ( 1.0 - rx ) * v22;
 
  372             value = ry * vr1 + ( 1.0 - ry ) * vr2;
 
  379             int row = int( ( y - yInterval.
minValue() ) / m_data->dy );
 
  380             int col = int( ( x - xInterval.
minValue() ) / m_data->dx );
 
  387             if ( row >= m_data->numRows )
 
  388                 row = m_data->numRows - 1;
 
  390             if ( col >= m_data->numColumns )
 
  391                 col = m_data->numColumns - 1;
 
  393             value = m_data->value( row, col );
 
  400 void QwtMatrixRasterData::update()
 
  406     if ( m_data->numColumns > 0 )
 
  408         m_data->numRows = m_data->values.size() / m_data->numColumns;
 
  413             m_data->dx = xInterval.
width() / m_data->numColumns;
 
  415             m_data->dy = yInterval.
width() / m_data->numRows;
 
A class representing an interval.
double width() const
Return the width of an interval.
bool contains(double value) const
A class representing a matrix of values as raster data.
void setResampleMode(ResampleMode mode)
Set the resampling algorithm.
virtual double value(double x, double y) const override
virtual ~QwtMatrixRasterData()
Destructor.
virtual QwtInterval interval(Qt::Axis axis) const override final
ResampleMode
Resampling algorithm The default setting is NearestNeighbour;.
QwtMatrixRasterData()
Constructor.
void setValue(int row, int col, double value)
Change a single value in the matrix.
void setValueMatrix(const QVector< double > &values, int numColumns)
Assign a value matrix.
void setInterval(Qt::Axis, const QwtInterval &)
Assign the bounding interval for an axis.
virtual QRectF pixelHint(const QRectF &) const override
Calculate the pixel hint.
const QVector< double > valueMatrix() const
ResampleMode resampleMode() const