qwt_plot_spectrocurve.cpp

Go to the documentation of this file.

/******************************************************************************
 * 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_spectrocurve.h"
#include "qwt_color_map.h"
#include "qwt_scale_map.h"
#include "qwt_painter.h"
#include "qwt_text.h"
 
#include <qpainter.h>
 
class QwtPlotSpectroCurve::PrivateData
{
  public:
    PrivateData()
        : colorRange( 0.0, 1000.0 )
        , penWidth( 0.0 )
        , paintAttributes( QwtPlotSpectroCurve::ClipPoints )
    {
        colorMap = new QwtLinearColorMap();
    }
 
    ~PrivateData()
    {
        delete colorMap;
    }
 
    QwtColorMap* colorMap;
    QwtInterval colorRange;
    QVector< QRgb > colorTable;
    double penWidth;
    QwtPlotSpectroCurve::PaintAttributes paintAttributes;
};
 
QwtPlotSpectroCurve::QwtPlotSpectroCurve( const QwtText& title )
    : QwtPlotSeriesItem( title )
{
    init();
}
 
QwtPlotSpectroCurve::QwtPlotSpectroCurve( const QString& title )
    : QwtPlotSeriesItem( QwtText( title ) )
{
    init();
}
 
QwtPlotSpectroCurve::~QwtPlotSpectroCurve()
{
    delete m_data;
}
 
void QwtPlotSpectroCurve::init()
{
    setItemAttribute( QwtPlotItem::Legend );
    setItemAttribute( QwtPlotItem::AutoScale );
 
    m_data = new PrivateData;
    setData( new QwtPoint3DSeriesData() );
 
    setZ( 20.0 );
}
 
int QwtPlotSpectroCurve::rtti() const
{
    return QwtPlotItem::Rtti_PlotSpectroCurve;
}
 
void QwtPlotSpectroCurve::setPaintAttribute( PaintAttribute attribute, bool on )
{
    if ( on )
        m_data->paintAttributes |= attribute;
    else
        m_data->paintAttributes &= ~attribute;
}
 
bool QwtPlotSpectroCurve::testPaintAttribute( PaintAttribute attribute ) const
{
    return ( m_data->paintAttributes & attribute );
}
 
void QwtPlotSpectroCurve::setSamples( const QVector< QwtPoint3D >& samples )
{
    setData( new QwtPoint3DSeriesData( samples ) );
}
 
void QwtPlotSpectroCurve::setSamples(
    QwtSeriesData< QwtPoint3D >* data )
{
    setData( data );
}
 
void QwtPlotSpectroCurve::setColorMap( QwtColorMap* colorMap )
{
    if ( colorMap != m_data->colorMap )
    {
        delete m_data->colorMap;
        m_data->colorMap = colorMap;
    }
 
    legendChanged();
    itemChanged();
}
 
const QwtColorMap* QwtPlotSpectroCurve::colorMap() const
{
    return m_data->colorMap;
}
 
void QwtPlotSpectroCurve::setColorRange( const QwtInterval& interval )
{
    if ( interval != m_data->colorRange )
    {
        m_data->colorRange = interval;
 
        legendChanged();
        itemChanged();
    }
}
 
QwtInterval& QwtPlotSpectroCurve::colorRange() const
{
    return m_data->colorRange;
}
 
void QwtPlotSpectroCurve::setPenWidth(double penWidth)
{
    if ( penWidth < 0.0 )
        penWidth = 0.0;
 
    if ( m_data->penWidth != penWidth )
    {
        m_data->penWidth = penWidth;
 
        legendChanged();
        itemChanged();
    }
}
 
double QwtPlotSpectroCurve::penWidth() const
{
    return m_data->penWidth;
}
 
void QwtPlotSpectroCurve::drawSeries( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect, int from, int to ) const
{
    if ( !painter || dataSize() <= 0 )
        return;
 
    if ( to < 0 )
        to = dataSize() - 1;
 
    if ( from < 0 )
        from = 0;
 
    if ( from > to )
        return;
 
    drawDots( painter, xMap, yMap, canvasRect, from, to );
}
 
void QwtPlotSpectroCurve::drawDots( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect, int from, int to ) const
{
    if ( !m_data->colorRange.isValid() )
        return;
 
    const bool doAlign = QwtPainter::roundingAlignment( painter );
 
    const QwtColorMap::Format format = m_data->colorMap->format();
    if ( format == QwtColorMap::Indexed )
        m_data->colorTable = m_data->colorMap->colorTable256();
 
    const QwtSeriesData< QwtPoint3D >* series = data();
 
    for ( int i = from; i <= to; i++ )
    {
        const QwtPoint3D sample = series->sample( i );
 
        double xi = xMap.transform( sample.x() );
        double yi = yMap.transform( sample.y() );
        if ( doAlign )
        {
            xi = qRound( xi );
            yi = qRound( yi );
        }
 
        if ( m_data->paintAttributes & QwtPlotSpectroCurve::ClipPoints )
        {
            if ( !canvasRect.contains( xi, yi ) )
                continue;
        }
 
        if ( format == QwtColorMap::RGB )
        {
            const QRgb rgb = m_data->colorMap->rgb(
                m_data->colorRange, sample.z() );
 
            painter->setPen( QPen( QColor::fromRgba( rgb ), m_data->penWidth ) );
        }
        else
        {
            const unsigned char index = m_data->colorMap->colorIndex(
                256, m_data->colorRange, sample.z() );
 
            painter->setPen( QPen( QColor::fromRgba( m_data->colorTable[index] ),
                m_data->penWidth ) );
        }
 
        QwtPainter::drawPoint( painter, QPointF( xi, yi ) );
    }
 
    m_data->colorTable.clear();
}