Пример #1
0
    SpectrogramData()
    {
//         setInterval( Qt::XAxis, QwtInterval( -1.5, 1.5 ) );
        setInterval( Qt::XAxis, QwtInterval( -1.5, 1.5 ) );
        setInterval( Qt::YAxis, QwtInterval( -1.5, 1.5 ) );
        setInterval( Qt::ZAxis, QwtInterval( 0.0, 10.0 ) );
    }
Пример #2
0
PlotRasterData::PlotRasterData()
{
    setInterval( Qt::XAxis, QwtInterval( -100, 100, QwtInterval::ExcludeMaximum ) );
    setInterval( Qt::YAxis, QwtInterval( -100, 100, QwtInterval::ExcludeMaximum ) );
    setInterval( Qt::ZAxis, QwtInterval( 0.1, 2.0 ) );
    setResampleMode( static_cast<QwtMatrixRasterData::ResampleMode>( 1 ) );     // Сглаживание
}
Пример #3
0
SaxsviewFrameData::SaxsviewFrameData(const QSize& size)
  : QwtRasterData(), p(new Private) {

  p->data = saxs_image_create();
  saxs_image_set_size(p->data, size.width(), size.height(), 1, 1);

  setInterval(Qt::XAxis, QwtInterval(0.0, size.width() - 1.0));
  setInterval(Qt::YAxis, QwtInterval(0.0, size.height() - 1.0));
  setInterval(Qt::ZAxis, QwtInterval(0.0, 1.0));
}
Пример #4
0
    SpectrogramData()
    {
        // some minor performance improvements wgen the spectrogram item
        // does not need to check for NaN values

        setAttribute( QwtRasterData::WithoutGaps, true );

        setInterval( Qt::XAxis, QwtInterval( -1.5, 1.5 ) );
        setInterval( Qt::YAxis, QwtInterval( -1.5, 1.5 ) );
        setInterval( Qt::ZAxis, QwtInterval( 0.0, 10.0 ) );
    }
Пример #5
0
QwtInterval QwtScaleEngine::buildInterval( double value ) const
{
    const double delta = ( value == 0.0 ) ? 0.5 : qAbs( 0.5 * value );

    if ( DBL_MAX - delta < value )
        return QwtInterval( DBL_MAX - delta, DBL_MAX );

    if ( -DBL_MAX + delta > value )
        return QwtInterval( -DBL_MAX, -DBL_MAX + delta );

    return QwtInterval( value - delta, value + delta );
}
Пример #6
0
QwtInterval QwtScaleEngine::buildInterval( double v ) const
{
    const double delta = ( v == 0.0 ) ? 0.5 : qAbs( 0.5 * v );

    if ( DBL_MAX - delta < v )
        return QwtInterval( DBL_MAX - delta, DBL_MAX );

    if ( -DBL_MAX + delta > v )
        return QwtInterval( -DBL_MAX, -DBL_MAX + delta );

    return QwtInterval( v - delta, v + delta );
}
Пример #7
0
/*!
   Interval, that is necessary to display the item
   This interval can be useful for operations like clipping or autoscaling

   \param scaleId Scale index
   \return bounding interval

   \sa QwtData::boundingRect()
*/
QwtInterval QwtPolarCurve::boundingInterval( int scaleId ) const
{
    const QRectF boundingRect = d_series->boundingRect();

    if ( scaleId == QwtPolar::ScaleAzimuth )
        return QwtInterval( boundingRect.left(), boundingRect.right() );

    if ( scaleId == QwtPolar::ScaleRadius )
        return QwtInterval( boundingRect.top(), boundingRect.bottom() );

    return QwtInterval();
}
/*!
  Return interval of an axis
  \param axis Axis index ( see QwtPlot::AxisId )
*/
QwtInterval QwtPlotRescaler::interval( int axis ) const
{
    if ( axis < 0 || axis >= QwtPlot::axisCnt )
        return QwtInterval();

    const QwtPlot *plt = plot();

    const double v1 = plt->axisScaleDiv( axis )->lowerBound();
    const double v2 = plt->axisScaleDiv( axis )->upperBound();

    return QwtInterval( v1, v2 ).normalized();
}
Пример #9
0
void FractalControl::setIntervals()
{
  const QStringList sl(m_intervalsEdit->text().split(","));
  
  if (sl.size() == 4)
  {
    setIntervals(
      QwtInterval(sl[0].toDouble(), sl[1].toDouble()),    
      QwtInterval(sl[2].toDouble(), sl[3].toDouble()));
      
    emit changedIntervals();
  }
}
Пример #10
0
void PlotZoz::setData(QVector<double> vecData, float fZoSide, QColor clrPlot, float fPen)
{
    pltRasterData->setValueMatrix( vecData, sqrt(vecData.size()) );
    pltSpectrogram->setRenderThreadCount( 0 ); // use system specific thread count
    pltSpectrogram->setData(pltRasterData);

    if (fZoSide != 0) {
        pltRasterData->setInterval( Qt::XAxis, QwtInterval( -fZoSide, fZoSide, QwtInterval::ExcludeMaximum ) );
        pltRasterData->setInterval( Qt::YAxis, QwtInterval( -fZoSide, fZoSide, QwtInterval::ExcludeMaximum ) );
    }
    pltSpectrogram->setDefaultContourPen(clrPlot, fPen, Qt::SolidLine);
    pltSpectrogram->attach( this );
}
Пример #11
0
RasterData::RasterData(MouseSpectrogram *spectrogram) :
    s(spectrogram),
    max(0)
{
  memset(d, 0, Statistic::SCREEN_SIZE * Statistic::SCREEN_SIZE * sizeof(int));
  setInterval(Qt::XAxis,
              QwtInterval(0.0, Statistic::SCREEN_SIZE));
  setInterval(Qt::YAxis,
              QwtInterval(0.0, Statistic::SCREEN_SIZE));

  s->setAxisScale(QwtPlot::xBottom, 0, Statistic::SCREEN_SIZE);
  s->setAxisScale(QwtPlot::yLeft, Statistic::SCREEN_SIZE, 0);
  s->setAxisScale(QwtPlot::yRight, 0.0, 1.0);
}
Пример #12
0
/*!
  \brief Align an interval to a step size

  The limits of an interval are aligned that both are integer
  multiples of the step size.

  \param interval Interval
  \param stepSize Step size

  \return Aligned interval
*/
QwtInterval QwtLinearScaleEngine::align(
    const QwtInterval &interval, double stepSize ) const
{
    double x1 = interval.minValue();
    double x2 = interval.maxValue();

    // when there is no rounding beside some effect, when
    // calculating with doubles, we keep the original value

    const double eps = 0.000000000001; // since Qt 4.8: qFuzzyIsNull
    if ( -DBL_MAX + stepSize <= x1 )
    {
        const double x = QwtScaleArithmetic::floorEps( x1, stepSize );
        if ( qAbs(x) <= eps || !qFuzzyCompare( x1, x ) )
            x1 = x;
    }

    if ( DBL_MAX - stepSize >= x2 )
    {
        const double x = QwtScaleArithmetic::ceilEps( x2, stepSize );
        if ( qAbs(x) <= eps || !qFuzzyCompare( x2, x ) )
            x2 = x;
    }

    return QwtInterval( x1, x2 );
}
Пример #13
0
SaxsviewFrameData::SaxsviewFrameData(const QString& fileName)
 : QwtRasterData(), p(new Private) {

  p->data = saxs_image_create();
  if (saxs_image_read(p->data, qPrintable(fileName), 0L) == 0) {

    setInterval(Qt::XAxis, QwtInterval(0.0, saxs_image_width(p->data) - 1.0));
    setInterval(Qt::YAxis, QwtInterval(0.0, saxs_image_height(p->data) - 1.0));
    setInterval(Qt::ZAxis, QwtInterval(saxs_image_value_min(p->data),
                                       saxs_image_value_max(p->data)));

  } else {
    saxs_image_free(p->data);
    p->data = 0L;
  }
}
Пример #14
0
void Plot::incrementInterval()
{
    d_interval = QwtInterval(d_interval.maxValue(),
        d_interval.maxValue() + d_interval.width());

    CurveData *data0 = static_cast<CurveData *>( d_curve0->data() );
    CurveData *data1 = static_cast<CurveData *>( d_curve1->data() );
    data0->clearStaleVal(d_interval.minValue());
    data1->clearStaleVal(d_interval.minValue());

    QwtScaleDiv scaleDiv = *axisScaleDiv(QwtPlot::xBottom);
    scaleDiv.setInterval(d_interval);

    for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ )
    {
        QList<double> ticks = scaleDiv.ticks(i);
        for ( int j = 0; j < ticks.size(); j++ )
            ticks[j] += d_interval.width();
        scaleDiv.setTicks(i, ticks);
    }
    setAxisScaleDiv(QwtPlot::xBottom, scaleDiv);

    d_origin->setValue(d_interval.minValue() + d_interval.width() / 2.0, 0.0);

    d_paintedPoints0 = 0;
    d_paintedPoints1 = 0;
    replot();
}
Пример #15
0
/*!
   \brief Calculate a scale division

   \param x1 First interval limit
   \param x2 Second interval limit
   \param maxMajorSteps Maximum for the number of major steps
   \param maxMinorSteps Maximum number of minor steps
   \param stepSize Step size. If stepSize == 0, the engine
                   calculates one.
*/
QwtScaleDiv QwtLinearScaleEngine::divideScale( double x1, double x2,
    int maxMajorSteps, int maxMinorSteps, double stepSize ) const
{
    QwtInterval interval = QwtInterval( x1, x2 ).normalized();
    if ( interval.width() <= 0 )
        return QwtScaleDiv();

    stepSize = qAbs( stepSize );
    if ( stepSize == 0.0 )
    {
        if ( maxMajorSteps < 1 )
            maxMajorSteps = 1;

        stepSize = QwtScaleArithmetic::divideInterval( 
            interval.width(), maxMajorSteps, base() );
    }

    QwtScaleDiv scaleDiv;

    if ( stepSize != 0.0 )
    {
        QList<double> ticks[QwtScaleDiv::NTickTypes];
        buildTicks( interval, stepSize, maxMinorSteps, ticks );

        scaleDiv = QwtScaleDiv( interval, ticks );
    }

    if ( x1 > x2 )
        scaleDiv.invert();

    return scaleDiv;
}
Пример #16
0
static QwtInterval qwtExpandedZoomInterval( double v1, double v2,
    double minRange, const QwtTransform* transform )
{
    double min = v1;
    double max = v2;

    if ( max - min < minRange )
    {
        min = 0.5 * ( min + max - minRange );
        max = min + minRange;

        if ( transform )
        {
            // f.e the logarithmic scale doesn't allow values
            // outside [QwtLogTransform::LogMin/QwtLogTransform::LogMax]

            double minBounded = transform->bounded( min );
            double maxBounded = transform->bounded( max );

            if ( minBounded != min )
            {
                maxBounded = transform->bounded( minBounded + minRange );
            }
            else if ( maxBounded != max )
            {
                minBounded = transform->bounded( maxBounded - minRange );
            }

            min = minBounded;
            max = maxBounded;
        }
    }

    return QwtInterval( min, max );
}
Пример #17
0
/*!
  \brief Return the current interval of the specified axis

  This is only a convenience function for axisScaleDiv( axisId )->interval();
  
  \param axisId axis index
  \return Scale interval

  \sa QwtScaleDiv, axisScaleDiv()
*/
QwtInterval QwtPlot::axisInterval( int axisId ) const
{
    if ( !axisValid( axisId ) )
        return QwtInterval();

    return d_axisData[axisId]->scaleDiv.interval();
}
void OscilloscopePlot::incrementInterval()
{
    d_interval = QwtInterval( d_interval.maxValue(),
        d_interval.maxValue() + d_interval.width() );

    CurveData *data = static_cast<CurveData *>( d_curve->data() );
    data->values().clearStaleValues( d_interval.minValue() );

    // To avoid, that the grid is jumping, we disable
    // the autocalculation of the ticks and shift them
    // manually instead.

    QwtScaleDiv scaleDiv = axisScaleDiv( QwtPlot::xBottom );
    scaleDiv.setInterval( d_interval );

    for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ )
    {
        QList<double> ticks = scaleDiv.ticks( i );
        for ( int j = 0; j < ticks.size(); j++ )
            ticks[j] += d_interval.width();
        scaleDiv.setTicks( i, ticks );
    }
    setAxisScaleDiv( QwtPlot::xBottom, scaleDiv );

    d_origin->setValue( d_interval.minValue() + d_interval.width() / 2.0, 0.0 );

    d_paintedPoints = 0;
    replot();
}
Пример #19
0
/*!
  \param axis Axis index ( see QwtPlot::AxisId )
  \return Normalized interval of an axis
*/
QwtInterval QwtPlotRescaler::interval( int axis ) const
{
    if ( axis < 0 || axis >= QwtPlot::axisCnt )
        return QwtInterval();

    return plot()->axisScaleDiv( axis ).interval().normalized();
}
Пример #20
0
/*!
   \return Bounding interval for an axis

   The default implementation returns the interval of the
   associated raster data object.

   \param axis X, Y, or Z axis
   \sa QwtRasterData::interval()
*/
QwtInterval QwtPlotSpectrogram::interval(Qt::Axis axis) const
{
    if ( d_data->data == NULL )
        return QwtInterval();

    return d_data->data->interval( axis );
}
Пример #21
0
/*!
  \param axis Axis, see QwtPlot::Axis
  \return Interval hint
  \sa setIntervalHint(), RescalePolicy
*/
QwtInterval QwtPlotRescaler::intervalHint( int axis ) const
{
    if ( axis >= 0 && axis < QwtPlot::axisCnt )
        return d_data->axisData[axis].intervalHint;

    return QwtInterval();
}
Пример #22
0
// could have just connected signal to slot
// but might want to be more sophisticated in future
void WSModel::onDataChanged() 
{ 
    // calc tau etc and make sure the interval is
    // set correctly - i.e. 'domain of validity'
    deriveCPParameters(4); 
    setInterval(QwtInterval(tau, PDMODEL_MAXT));

}
Пример #23
0
/*!
  Draw a sample

  \param painter Painter
  \param xMap x map
  \param yMap y map
  \param canvasRect Contents rect of the canvas
  \param boundingInterval Bounding interval of sample values
  \param index Index of the sample
  \param sample Value of the sample

  \sa drawSeries()
*/
void QwtPlotBarChart::drawSample( QPainter *painter,
    const QwtScaleMap &xMap, const QwtScaleMap &yMap,
    const QRectF &canvasRect, const QwtInterval &boundingInterval,
    int index, const QPointF &sample ) const
{
    QwtColumnRect barRect;

    if ( orientation() == Qt::Horizontal )
    {
        const double barHeight = sampleWidth( yMap, canvasRect.height(),
            boundingInterval.width(), sample.y() );

        const double x1 = xMap.transform( baseline() );
        const double x2 = xMap.transform( sample.y() );

        const double y = yMap.transform( sample.x() );
        const double y1 = y - 0.5 * barHeight;
        const double y2 = y + 0.5 * barHeight;

        barRect.direction = ( x1 < x2 ) ?
            QwtColumnRect::LeftToRight : QwtColumnRect::RightToLeft;

        barRect.hInterval = QwtInterval( x1, x2 ).normalized();
        barRect.vInterval = QwtInterval( y1, y2 );
    }
    else
    {
        const double barWidth = sampleWidth( xMap, canvasRect.width(),
            boundingInterval.width(), sample.y() );

        const double x = xMap.transform( sample.x() );
        const double x1 = x - 0.5 * barWidth;
        const double x2 = x + 0.5 * barWidth;

        const double y1 = yMap.transform( baseline() );
        const double y2 = yMap.transform( sample.y() );

        barRect.direction = ( y1 < y2 ) ?
            QwtColumnRect::TopToBottom : QwtColumnRect::BottomToTop;

        barRect.hInterval = QwtInterval( x1, x2 );
        barRect.vInterval = QwtInterval( y1, y2 ).normalized();
    }

    drawBar( painter, index, sample, barRect );
}
Пример #24
0
void Spectrogramplot::setYAxisRange(double yMin, double yMax)
{
  yMin_ = yMin;
  yMax_ = yMax;
  data_->setInterval( Qt::YAxis, QwtInterval( yMin_, yMax_ ) );
  plotLayout()->setAlignCanvasToScales(true);
  replot();
}
Пример #25
0
void Spectrogramplot::setXAxisRange(double xMin, double xMax)
{
  xMin_ = xMin;
  xMax_ = xMax;
  data_->setInterval( Qt::XAxis, QwtInterval( xMin_, xMax_ ) );
  plotLayout()->setAlignCanvasToScales(true);
  replot();
}
Пример #26
0
/*!
   \brief Calculate a scale division for an interval

   \param x1 First interval limit
   \param x2 Second interval limit
   \param maxMajorSteps Maximum for the number of major steps
   \param maxMinorSteps Maximum number of minor steps
   \param stepSize Step size. If stepSize == 0, the engine
                   calculates one.

   \return Calculated scale division
*/
QwtScaleDiv QwtLogScaleEngine::divideScale( double x1, double x2,
    int maxMajorSteps, int maxMinorSteps, double stepSize ) const
{
    QwtInterval interval = QwtInterval( x1, x2 ).normalized();
    interval = interval.limited( LOG_MIN, LOG_MAX );

    if ( interval.width() <= 0 )
        return QwtScaleDiv();

    const double logBase = base();

    if ( interval.maxValue() / interval.minValue() < logBase )
    {
        // scale width is less than one decade -> build linear scale

        QwtLinearScaleEngine linearScaler;
        linearScaler.setAttributes( attributes() );
        linearScaler.setReference( reference() );
        linearScaler.setMargins( lowerMargin(), upperMargin() );

        if ( stepSize != 0.0 )
        {
            if ( stepSize < 0.0 )
                stepSize = -qPow( logBase, -stepSize );
            else
                stepSize = qPow( logBase, stepSize );
        }

        return linearScaler.divideScale( x1, x2,
            maxMajorSteps, maxMinorSteps, stepSize );
    }

    stepSize = qAbs( stepSize );
    if ( stepSize == 0.0 )
    {
        if ( maxMajorSteps < 1 )
            maxMajorSteps = 1;

        stepSize = divideInterval( 
            qwtLogInterval( logBase, interval ).width(), maxMajorSteps );
        if ( stepSize < 1.0 )
            stepSize = 1.0; // major step must be >= 1 decade
    }

    QwtScaleDiv scaleDiv;
    if ( stepSize != 0.0 )
    {
        QList<double> ticks[QwtScaleDiv::NTickTypes];
        buildTicks( interval, stepSize, maxMinorSteps, ticks );

        scaleDiv = QwtScaleDiv( interval, ticks );
    }

    if ( x1 > x2 )
        scaleDiv.invert();

    return scaleDiv;
}
Пример #27
0
void
PDModel::setMinutes(bool x)
{
    minutes = x;
    if (minutes) {
        setInterval(QwtInterval(1.00f / 60.00f, double(PDMODEL_MAXT)/ 60.00f));
        setSize(PDMODEL_MAXT);
    }
}
Пример #28
0
void EventViewer::updatePlot(_EVENT evt)
{
    if (!integrate_chbx->isChecked()) rasterData->resetData();
    foreach (_HIT hit, evt.hits) rasterData->increment(hit.X_address, hit.Y_address);
    //for (int i =0; i < evt.hits.size(); i++)rasterData->increment(evt.hits[i].X_address, evt.hits[i].Y_address);
    rasterData->setInterval( Qt::ZAxis, QwtInterval( 0.0, (double)rasterData->getMaxBin().first ));
    evt_plot->updateScale();
    evt_plot->replot();
}
Пример #29
0
WaterfallData::WaterfallData(
                              double minimumFrequency,
                              double maximumFrequency,
                              uint64_t fftPoints,
                              unsigned int historyExtent
                               ): QwtMatrixRasterData()
{

    _fftPoints = fftPoints;
    _historyLength = historyExtent;
    _spectrumData = new double[_fftPoints*_historyLength];
    setInterval( Qt::XAxis, QwtInterval( minimumFrequency, maximumFrequency ) );
    setInterval( Qt::YAxis, QwtInterval( 0, historyExtent ) );
    setInterval( Qt::ZAxis, QwtInterval( MIN_INTENSITY, MAX_INTENSITY ) );
    Reset();


}
Пример #30
0
// could have just connected signal to slot
// but might want to be more sophisticated in future
void
ExtendedModel::onDataChanged()
{
    // calc tau etc and make sure the interval is
    // set corretly - i.e. 'domain of validity'
    deriveExtCPParameters();
    setInterval(QwtInterval(etau, PDMODEL_MAXT));

}