qwt_plot_spectrogram.cpp

/******************************************************************************
 * 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_plot_spectrogram.h"
#include "qwt_painter.h"
#include "qwt_interval.h"
#include "qwt_scale_map.h"
#include "qwt_color_map.h"
#include "qwt_math.h"
 
#include <qimage.h>
#include <qpen.h>
#include <qpainter.h>
#include <qthread.h>
#include <qfuture.h>
#include <qtconcurrentrun.h>
 
#define DEBUG_RENDER 0
 
#if DEBUG_RENDER
#include <qelapsedtimer.h>
#endif
 
#include <algorithm>
 
static inline bool qwtIsNaN( double d )
{
    // qt_is_nan is private header and qIsNaN is not inlined
    // so we need these code here too
 
    const uchar* ch = (const uchar*)&d;
    if ( QSysInfo::ByteOrder == QSysInfo::BigEndian )
    {
        return ( ch[0] & 0x7f ) == 0x7f && ch[1] > 0xf0;
    }
    else
    {
        return ( ch[7] & 0x7f ) == 0x7f && ch[6] > 0xf0;
    }
}
 
class QwtPlotSpectrogram::PrivateData
{
  public:
    PrivateData()
        : data( NULL )
        , colorTableSize( 0 )
    {
        colorMap = new QwtLinearColorMap();
        displayMode = ImageMode;
 
        conrecFlags = QwtRasterData::IgnoreAllVerticesOnLevel;
#if 0
        conrecFlags |= QwtRasterData::IgnoreOutOfRange;
#endif
    }
 
    ~PrivateData()
    {
        delete data;
        delete colorMap;
    }
 
    void updateColorTable()
    {
        if ( colorMap->format() == QwtColorMap::Indexed )
        {
            colorTable = colorMap->colorTable256();
        }
        else
        {
            if ( colorTableSize == 0 )
                colorTable.clear();
            else
                colorTable = colorMap->colorTable( colorTableSize );
        }
    }
 
    QwtRasterData* data;
    QwtColorMap* colorMap;
    DisplayModes displayMode;
 
    QList< double > contourLevels;
    QPen defaultContourPen;
    QwtRasterData::ConrecFlags conrecFlags;
 
    int colorTableSize;
    QVector< QRgb > colorTable;
};
 
QwtPlotSpectrogram::QwtPlotSpectrogram( const QString& title )
    : QwtPlotRasterItem( title )
{
    m_data = new PrivateData();
 
    setItemAttribute( QwtPlotItem::AutoScale, true );
    setItemAttribute( QwtPlotItem::Legend, false );
 
    setZ( 8.0 );
}
 
QwtPlotSpectrogram::~QwtPlotSpectrogram()
{
    delete m_data;
}
 
int QwtPlotSpectrogram::rtti() const
{
    return QwtPlotItem::Rtti_PlotSpectrogram;
}
 
void QwtPlotSpectrogram::setDisplayMode( DisplayMode mode, bool on )
{
    if ( on != bool( mode & m_data->displayMode ) )
    {
        if ( on )
            m_data->displayMode |= mode;
        else
            m_data->displayMode &= ~mode;
    }
 
    legendChanged();
    itemChanged();
}
 
bool QwtPlotSpectrogram::testDisplayMode( DisplayMode mode ) const
{
    return ( m_data->displayMode & mode );
}
 
void QwtPlotSpectrogram::setColorMap( QwtColorMap* colorMap )
{
    if ( colorMap == NULL )
        return;
 
    if ( colorMap != m_data->colorMap )
    {
        delete m_data->colorMap;
        m_data->colorMap = colorMap;
    }
 
    m_data->updateColorTable();
 
    invalidateCache();
 
    legendChanged();
    itemChanged();
}
 
const QwtColorMap* QwtPlotSpectrogram::colorMap() const
{
    return m_data->colorMap;
}
 
void QwtPlotSpectrogram::setColorTableSize( int numColors )
{
    numColors = qMax( numColors, 0 );
    if ( numColors != m_data->colorTableSize )
    {
        m_data->colorTableSize = numColors;
        m_data->updateColorTable();
        invalidateCache();
    }
}
int QwtPlotSpectrogram::colorTableSize() const
{
    return m_data->colorTableSize;
}
 
void QwtPlotSpectrogram::setDefaultContourPen(
    const QColor& color, qreal width, Qt::PenStyle style )
{
    setDefaultContourPen( QPen( color, width, style ) );
}
 
void QwtPlotSpectrogram::setDefaultContourPen( const QPen& pen )
{
    if ( pen != m_data->defaultContourPen )
    {
        m_data->defaultContourPen = pen;
 
        legendChanged();
        itemChanged();
    }
}
 
QPen QwtPlotSpectrogram::defaultContourPen() const
{
    return m_data->defaultContourPen;
}
 
QPen QwtPlotSpectrogram::contourPen( double level ) const
{
    if ( m_data->data == NULL || m_data->colorMap == NULL )
        return QPen();
 
    const QwtInterval intensityRange = m_data->data->interval(Qt::ZAxis);
    const QColor c( m_data->colorMap->rgb( intensityRange, level ) );
 
    return QPen( c );
}
 
void QwtPlotSpectrogram::setConrecFlag(
    QwtRasterData::ConrecFlag flag, bool on )
{
    if ( bool( m_data->conrecFlags & flag ) == on )
        return;
 
    if ( on )
        m_data->conrecFlags |= flag;
    else
        m_data->conrecFlags &= ~flag;
 
    itemChanged();
}
 
bool QwtPlotSpectrogram::testConrecFlag(
    QwtRasterData::ConrecFlag flag ) const
{
    return m_data->conrecFlags & flag;
}
 
void QwtPlotSpectrogram::setContourLevels( const QList< double >& levels )
{
    m_data->contourLevels = levels;
    std::sort( m_data->contourLevels.begin(), m_data->contourLevels.end() );
 
    legendChanged();
    itemChanged();
}
 
QList< double > QwtPlotSpectrogram::contourLevels() const
{
    return m_data->contourLevels;
}
 
void QwtPlotSpectrogram::setData( QwtRasterData* data )
{
    if ( data != m_data->data )
    {
        delete m_data->data;
        m_data->data = data;
 
        invalidateCache();
        itemChanged();
    }
}
 
const QwtRasterData* QwtPlotSpectrogram::data() const
{
    return m_data->data;
}
 
QwtRasterData* QwtPlotSpectrogram::data()
{
    return m_data->data;
}
 
QwtInterval QwtPlotSpectrogram::interval(Qt::Axis axis) const
{
    if ( m_data->data == NULL )
        return QwtInterval();
 
    return m_data->data->interval( axis );
}
 
QRectF QwtPlotSpectrogram::pixelHint( const QRectF& area ) const
{
    if ( m_data->data == NULL )
        return QRectF();
 
    return m_data->data->pixelHint( area );
}
 
QImage QwtPlotSpectrogram::renderImage(
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& area, const QSize& imageSize ) const
{
    if ( imageSize.isEmpty() || m_data->data == NULL
        || m_data->colorMap == NULL )
    {
        return QImage();
    }
 
    const QwtInterval intensityRange = m_data->data->interval( Qt::ZAxis );
    if ( !intensityRange.isValid() )
        return QImage();
 
    const QImage::Format format = ( m_data->colorMap->format() == QwtColorMap::RGB )
        ? QImage::Format_ARGB32 : QImage::Format_Indexed8;
 
    QImage image( imageSize, format );
 
    if ( m_data->colorMap->format() == QwtColorMap::Indexed )
        image.setColorTable( m_data->colorMap->colorTable256() );
 
    m_data->data->initRaster( area, image.size() );
 
#if DEBUG_RENDER
    QElapsedTimer time;
    time.start();
#endif
 
#if !defined( QT_NO_QFUTURE )
    uint numThreads = renderThreadCount();
 
    if ( numThreads <= 0 )
        numThreads = QThread::idealThreadCount();
 
    if ( numThreads <= 0 )
        numThreads = 1;
 
    const int numRows = imageSize.height() / numThreads;
 
    QVector< QFuture< void > > futures;
    futures.reserve( numThreads - 1 );
 
    for ( uint i = 0; i < numThreads; i++ )
    {
        QRect tile( 0, i * numRows, image.width(), numRows );
        if ( i == numThreads - 1 )
        {
            tile.setHeight( image.height() - i * numRows );
            renderTile( xMap, yMap, tile, &image );
        }
        else
        {
            futures += QtConcurrent::run(
#if QT_VERSION >= 0x060000
                &QwtPlotSpectrogram::renderTile, this,
#else
                this, &QwtPlotSpectrogram::renderTile,
#endif
                xMap, yMap, tile, &image );
        }
    }
 
    for ( int i = 0; i < futures.size(); i++ )
        futures[i].waitForFinished();
 
#else
    const QRect tile( 0, 0, image.width(), image.height() );
    renderTile( xMap, yMap, tile, &image );
#endif
 
#if DEBUG_RENDER
    const qint64 elapsed = time.elapsed();
    qDebug() << "renderImage" << imageSize << elapsed;
#endif
 
    m_data->data->discardRaster();
 
    return image;
}
 
void QwtPlotSpectrogram::renderTile(
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRect& tile, QImage* image ) const
{
    const QwtInterval range = m_data->data->interval( Qt::ZAxis );
    if ( range.width() <= 0.0 )
        return;
 
    const bool hasGaps = !m_data->data->testAttribute( QwtRasterData::WithoutGaps );
 
    if ( m_data->colorMap->format() == QwtColorMap::RGB )
    {
        const int numColors = m_data->colorTable.size();
        const QRgb* rgbTable = m_data->colorTable.constData();
        const QwtColorMap* colorMap = m_data->colorMap;
 
        for ( int y = tile.top(); y <= tile.bottom(); y++ )
        {
            const double ty = yMap.invTransform( y );
 
            QRgb* line = reinterpret_cast< QRgb* >( image->scanLine( y ) );
            line += tile.left();
 
            for ( int x = tile.left(); x <= tile.right(); x++ )
            {
                const double tx = xMap.invTransform( x );
 
                const double value = m_data->data->value( tx, ty );
 
                if ( hasGaps && qwtIsNaN( value ) )
                {
                    *line++ = 0u;
                }
                else if ( numColors == 0 )
                {
                    *line++ = colorMap->rgb( range, value );
                }
                else
                {
                    const uint index = colorMap->colorIndex( numColors, range, value );
                    *line++ = rgbTable[index];
                }
            }
        }
    }
    else if ( m_data->colorMap->format() == QwtColorMap::Indexed )
    {
        for ( int y = tile.top(); y <= tile.bottom(); y++ )
        {
            const double ty = yMap.invTransform( y );
 
            unsigned char* line = image->scanLine( y );
            line += tile.left();
 
            for ( int x = tile.left(); x <= tile.right(); x++ )
            {
                const double tx = xMap.invTransform( x );
 
                const double value = m_data->data->value( tx, ty );
 
                if ( hasGaps && qwtIsNaN( value ) )
                {
                    *line++ = 0;
                }
                else
                {
                    const uint index = m_data->colorMap->colorIndex( 256, range, value );
                    *line++ = static_cast< unsigned char >( index );
                }
            }
        }
    }
}
 
QSize QwtPlotSpectrogram::contourRasterSize(
    const QRectF& area, const QRect& rect ) const
{
    QSize raster = rect.size() / 2;
 
    const QRectF pixelRect = pixelHint( area );
    if ( !pixelRect.isEmpty() )
    {
        const QSize res( qwtCeil( rect.width() / pixelRect.width() ),
            qwtCeil( rect.height() / pixelRect.height() ) );
        raster = raster.boundedTo( res );
    }
 
    return raster;
}
 
QwtRasterData::ContourLines QwtPlotSpectrogram::renderContourLines(
    const QRectF& rect, const QSize& raster ) const
{
    if ( m_data->data == NULL )
        return QwtRasterData::ContourLines();
 
    return m_data->data->contourLines( rect, raster,
        m_data->contourLevels, m_data->conrecFlags );
}
 
void QwtPlotSpectrogram::drawContourLines( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QwtRasterData::ContourLines& contourLines ) const
{
    if ( m_data->data == NULL )
        return;
 
    const int numLevels = m_data->contourLevels.size();
    for ( int l = 0; l < numLevels; l++ )
    {
        const double level = m_data->contourLevels[l];
 
        QPen pen = defaultContourPen();
        if ( pen.style() == Qt::NoPen )
            pen = contourPen( level );
 
        if ( pen.style() == Qt::NoPen )
            continue;
 
        painter->setPen( pen );
 
        const QPolygonF& lines = contourLines[level];
        for ( int i = 0; i < lines.size(); i += 2 )
        {
            const QPointF p1( xMap.transform( lines[i].x() ),
                yMap.transform( lines[i].y() ) );
            const QPointF p2( xMap.transform( lines[i + 1].x() ),
                yMap.transform( lines[i + 1].y() ) );
 
            QwtPainter::drawLine( painter, p1, p2 );
        }
    }
}
 
void QwtPlotSpectrogram::draw( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect ) const
{
    if ( m_data->displayMode & ImageMode )
        QwtPlotRasterItem::draw( painter, xMap, yMap, canvasRect );
 
    if ( m_data->displayMode & ContourMode )
    {
        // Add some pixels at the borders
        const int margin = 2;
        QRectF rasterRect( canvasRect.x() - margin, canvasRect.y() - margin,
            canvasRect.width() + 2 * margin, canvasRect.height() + 2 * margin );
 
        QRectF area = QwtScaleMap::invTransform( xMap, yMap, rasterRect );
 
        const QRectF br = boundingRect();
        if ( br.isValid() )
        {
            area &= br;
            if ( area.isEmpty() )
                return;
 
            rasterRect = QwtScaleMap::transform( xMap, yMap, area );
        }
 
        QSize raster = contourRasterSize( area, rasterRect.toRect() );
        raster = raster.boundedTo( rasterRect.toRect().size() );
        if ( raster.isValid() )
        {
            const QwtRasterData::ContourLines lines =
                renderContourLines( area, raster );
 
            drawContourLines( painter, xMap, yMap, lines );
        }
    }
}