qwt_point_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_point_data.h"
#include "qwt_math.h"
#include <string.h>

QwtPointArrayData::QwtPointArrayData(
        const QVector<double> &x, const QVector<double> &y ):
    d_x( x ),
    d_y( y )
{
}

QwtPointArrayData::QwtPointArrayData( const double *x,
        const double *y, size_t size )
{
    d_x.resize( size );
    ::memcpy( d_x.data(), x, size * sizeof( double ) );

    d_y.resize( size );
    ::memcpy( d_y.data(), y, size * sizeof( double ) );
}

QRectF QwtPointArrayData::boundingRect() const
{
    if ( d_boundingRect.width() < 0 )
        d_boundingRect = qwtBoundingRect( *this );

    return d_boundingRect;
}

size_t QwtPointArrayData::size() const
{
    return qMin( d_x.size(), d_y.size() );
}

QPointF QwtPointArrayData::sample( size_t index ) const
{
    return QPointF( d_x[int( index )], d_y[int( index )] );
}

const QVector<double> &QwtPointArrayData::xData() const
{
    return d_x;
}

const QVector<double> &QwtPointArrayData::yData() const
{
    return d_y;
}

QwtCPointerData::QwtCPointerData(
        const double *x, const double *y, size_t size ):
    d_x( x ),
    d_y( y ),
    d_size( size )
{
}

QRectF QwtCPointerData::boundingRect() const
{
    if ( d_boundingRect.width() < 0 )
        d_boundingRect = qwtBoundingRect( *this );

    return d_boundingRect;
}

size_t QwtCPointerData::size() const
{
    return d_size;
}

QPointF QwtCPointerData::sample( size_t index ) const
{
    return QPointF( d_x[int( index )], d_y[int( index )] );
}

const double *QwtCPointerData::xData() const
{
    return d_x;
}

const double *QwtCPointerData::yData() const
{
    return d_y;
}

QwtSyntheticPointData::QwtSyntheticPointData(
        size_t size, const QwtInterval &interval ):
    d_size( size ),
    d_interval( interval )
{
}

void QwtSyntheticPointData::setSize( size_t size )
{
    d_size = size;
}

size_t QwtSyntheticPointData::size() const
{
    return d_size;
}

void QwtSyntheticPointData::setInterval( const QwtInterval &interval )
{
    d_interval = interval.normalized();
}

QwtInterval QwtSyntheticPointData::interval() const
{
    return d_interval;
}

void QwtSyntheticPointData::setRectOfInterest( const QRectF &rect )
{
    d_rectOfInterest = rect;
    d_intervalOfInterest = QwtInterval(
        rect.left(), rect.right() ).normalized();
}

QRectF QwtSyntheticPointData::rectOfInterest() const
{
    return d_rectOfInterest;
}

QRectF QwtSyntheticPointData::boundingRect() const
{
    if ( d_size == 0 ||
        !( d_interval.isValid() || d_intervalOfInterest.isValid() ) )
    {
        return QRectF( 1.0, 1.0, -2.0, -2.0 ); // something invalid
    }

    return qwtBoundingRect( *this );
}

QPointF QwtSyntheticPointData::sample( size_t index ) const
{
    if ( index >= d_size )
        return QPointF( 0, 0 );

    const double xValue = x( index );
    const double yValue = y( xValue );

    return QPointF( xValue, yValue );
}

double QwtSyntheticPointData::x( uint index ) const
{
    const QwtInterval &interval = d_interval.isValid() ?
        d_interval : d_intervalOfInterest;

    if ( !interval.isValid() ) 
        return 0.0;

    if ( d_size <= 1 )
        return interval.minValue();

    const double dx = interval.width() / ( d_size - 1 );
    return interval.minValue() + index * dx;
}