QwtScaleDiv ScaleEngine::divideScale(double x1, double x2, int maxMajSteps, int maxMinSteps, double stepSize) const { QwtScaleEngine *engine; if (!hasBreak()){ engine = newScaleEngine(); QwtScaleDiv div = engine->divideScale(x1, x2, maxMajSteps, maxMinSteps, stepSize); delete engine; return div; } double lb = d_break_left; double rb = d_break_right; double step1 = d_step_before; double step2 = d_step_after; if (x1 > x2){ lb = d_break_right; rb = d_break_left; step1 = d_step_after; step2 = d_step_before; if (d_log10_scale_after) engine = new QwtLog10ScaleEngine(); else engine = new QwtLinearScaleEngine(); } else engine = newScaleEngine(); int max_min_intervals = d_minor_ticks_before; if (d_minor_ticks_before == 1) max_min_intervals = 3; if (d_minor_ticks_before > 1) max_min_intervals = d_minor_ticks_before + 1; QwtScaleDiv div1 = engine->divideScale(x1, lb, maxMajSteps/2, max_min_intervals, step1); max_min_intervals = d_minor_ticks_after; if (d_minor_ticks_after == 1) max_min_intervals = 3; if (d_minor_ticks_after > 1) max_min_intervals = d_minor_ticks_after + 1; delete engine; if (testAttribute(QwtScaleEngine::Inverted)) engine = newScaleEngine(); else if (d_log10_scale_after) engine = new QwtLog10ScaleEngine(); else engine = new QwtLinearScaleEngine(); QwtScaleDiv div2 = engine->divideScale(rb, x2, maxMajSteps/2, max_min_intervals, step2); QwtValueList ticks[QwtScaleDiv::NTickTypes]; ticks[QwtScaleDiv::MinorTick] = div1.ticks(QwtScaleDiv::MinorTick) + div2.ticks(QwtScaleDiv::MinorTick); ticks[QwtScaleDiv::MediumTick] = div1.ticks(QwtScaleDiv::MediumTick) + div2.ticks(QwtScaleDiv::MediumTick); ticks[QwtScaleDiv::MajorTick] = div1.ticks(QwtScaleDiv::MajorTick) + div2.ticks(QwtScaleDiv::MajorTick); delete engine; return QwtScaleDiv(x1, x2, ticks); }
void initFreqSlider(QwtSlider * slider, int minValue, int maxValue, int initialValue) { slider->setLowerBound(minValue); slider->setUpperBound(maxValue); // Actually allow only two positions: min and max slider->setTotalSteps(1); // Therefore, only two major ticks slider->setScale(QwtScaleDiv(minValue, maxValue, QList<double>(), QList<double>(), QList<double>({FREQ_50, FREQ_200}))); slider->setValue(initialValue); }
/*! \brief Calculate a scale division for a date/time 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 scaleEngine calculates one. \return Calculated scale division */ QwtScaleDiv QwtDateScaleEngine::divideScale( double x1, double x2, int maxMajorSteps, int maxMinorSteps, double stepSize ) const { if ( maxMajorSteps < 1 ) maxMajorSteps = 1; const double min = qMin( x1, x2 ); const double max = qMax( x1, x2 ); const QDateTime from = toDateTime( min ); const QDateTime to = toDateTime( max ); if ( from == to ) return QwtScaleDiv(); stepSize = qAbs( stepSize ); if ( stepSize > 0.0 ) { // as interval types above hours are not equidistant // ( even days might have 23/25 hours because of daylight saving ) // the stepSize is used as a hint only maxMajorSteps = qCeil( ( max - min ) / stepSize ); } const QwtDate::IntervalType intvType = intervalType( from, to, maxMajorSteps ); QwtScaleDiv scaleDiv; if ( intvType == QwtDate::Millisecond ) { // for milliseconds and below we can use the decimal system scaleDiv = QwtLinearScaleEngine::divideScale( min, max, maxMajorSteps, maxMinorSteps, stepSize ); } else { const QDateTime minDate = QwtDate::floor( from, intvType ); const QDateTime maxDate = QwtDate::ceil( to, intvType ); scaleDiv = buildScaleDiv( minDate, maxDate, maxMajorSteps, maxMinorSteps, intvType ); // scaleDiv has been calculated from an extended interval // adjusted to the step size. We have to shrink it again. scaleDiv = scaleDiv.bounded( min, max ); } if ( x1 > x2 ) scaleDiv.invert(); return scaleDiv; }
/*! \brief Calculate a scale division \param x1 First interval limit \param x2 Second interval limit \param maxMajSteps Maximum for the number of major steps \param maxMinSteps Maximum number of minor steps \param stepSize Step size. If stepSize == 0, the scaleEngine calculates one. */ QwtScaleDiv Log2ScaleEngine::divideScale(double x1, double x2, int maxMajSteps, int maxMinSteps, double stepSize) const { QwtDoubleInterval interval = QwtDoubleInterval(x1, x2).normalized(); interval = interval.limited(LOG_MIN, LOG_MAX); if (interval.width() <= 0 ) return QwtScaleDiv(); if (interval.maxValue() / interval.minValue() < 2){ // scale width is less than 2 -> build linear scale QwtLinearScaleEngine linearScaler; linearScaler.setAttributes(attributes()); linearScaler.setReference(reference()); linearScaler.setMargins(lowerMargin(), upperMargin()); return linearScaler.divideScale(x1, x2, maxMajSteps, maxMinSteps, stepSize); } stepSize = qwtAbs(stepSize); if ( stepSize == 0.0 ){ if ( maxMajSteps < 1 ) maxMajSteps = 1; stepSize = ceil(log2(interval).width()/double(maxMajSteps)); } QwtScaleDiv scaleDiv; if ( stepSize != 0.0 ){ QwtValueList ticks[QwtScaleDiv::NTickTypes]; buildTicks(interval, stepSize, maxMinSteps, ticks); scaleDiv = QwtScaleDiv(interval, ticks); } if ( x1 > x2 ) scaleDiv.invert(); return scaleDiv; }
/*! Update the axes scales \param intervals Scale intervals */ void QwtPlotRescaler::updateScales( QwtDoubleInterval intervals[QwtPlot::axisCnt]) const { if ( d_data->inReplot >= 5 ) { return; } QwtPlot *plt = (QwtPlot *)plot(); const bool doReplot = plt->autoReplot(); plt->setAutoReplot(false); for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ ) { if ( axis == referenceAxis() || aspectRatio(axis) > 0.0 ) { double v1 = intervals[axis].minValue(); double v2 = intervals[axis].maxValue(); if ( plt->axisScaleDiv(axis)->lowerBound() > plt->axisScaleDiv(axis)->upperBound() ) { qSwap(v1, v2); } if ( d_data->inReplot >= 1 ) { d_data->axisData[axis].scaleDiv = *plt->axisScaleDiv(axis); } if ( d_data->inReplot >= 2 ) { QwtValueList ticks[QwtScaleDiv::NTickTypes]; for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ ) ticks[i] = d_data->axisData[axis].scaleDiv.ticks(i); plt->setAxisScaleDiv(axis, QwtScaleDiv(v1, v2, ticks)); } else { plt->setAxisScale(axis, v1, v2); } } } plt->setAutoReplot(doReplot); d_data->inReplot++; plt->replot(); d_data->inReplot--; }
/*! \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 QwtLinearScaleEngine::divideScale( double x1, double x2, int maxMajorSteps, int maxMinorSteps, double stepSize ) const { QwtInterval interval = QwtInterval( x1, x2 ).normalized(); if ( qwtIntervalWidthL( interval ) > std::numeric_limits<double>::max() ) { qWarning() << "QwtLinearScaleEngine::divideScale: overflow"; return QwtScaleDiv(); } 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; }
virtual void updateScaleDiv( const QwtScaleDiv &xMap, const QwtScaleDiv &yMap ) { QList<double> ticks[QwtScaleDiv::NTickTypes]; ticks[QwtScaleDiv::MajorTick] = xMap.ticks( QwtScaleDiv::MediumTick ); ticks[QwtScaleDiv::MinorTick] = xMap.ticks( QwtScaleDiv::MinorTick ); QwtPlotGrid::updateScaleDiv( QwtScaleDiv( xMap.lowerBound(), xMap.upperBound(), ticks ), yMap ); }
void SingleCellViewGraphPanelPlotWidget::setAxis(const int &pAxis, double pMin, double pMax) { // Set our axis // Note: to use setAxisScale() on its own is not sufficient unless we were // to replot ourselves immediately after, but we don't want to do // that, so instead we also use setAxisScaleDiv() to make sure that // our axis is indeed taken into account (i.e. we can retrieve them // using minX(), maxX(), minY() and maxY()). Also, we must call // setAxisScaleDiv() before setAxisScale() to make sure that the axis // data is not considered as valid, which is important when it comes // to plotting ourselves... setAxisScaleDiv(pAxis, QwtScaleDiv(pMin, pMax)); setAxisScale(pAxis, pMin, pMax); }
MUPlot::MUPlot(MUWidget *muw, CriticalPowerWindow *parent, Context *context) : QwtPlot(parent), QwtSyntheticPointData(MUN), context(context), muw(muw), parent(parent), modelCurve(NULL), slowCurve(NULL), fastCurve(NULL), mmpCurve(NULL) { // initalise all the model stufff // probably abstract this out later muSet = NULL; slowHandle = NULL; slowLine = NULL; slowDrag = false; fastHandle = NULL; fastLine = NULL; fastDrag = false; setAutoDelete(false); setAutoFillBackground(true); static_cast<QwtPlotCanvas*>(canvas())->setFrameStyle(QFrame::NoFrame); // left yAxis scale prettify QwtScaleDraw *sd = new QwtScaleDraw; sd->setTickLength(QwtScaleDiv::MajorTick, 3); sd->enableComponent(QwtScaleDraw::Ticks, false); sd->enableComponent(QwtScaleDraw::Backbone, false); setAxisScaleDraw(yLeft, sd); setAxisTitle(yLeft, tr("w(x)")); setAxisMaxMinor(yLeft, 0); plotLayout()->setAlignCanvasToScales(true); // 0.5 increments on bottom axis QwtValueList ytick[QwtScaleDiv::NTickTypes]; for (double i=0.0f; i<=10.0f; i+= 1.0) ytick[QwtScaleDiv::MajorTick]<<i; setAxisScaleDiv(yLeft,QwtScaleDiv(0.0f,10.0f,ytick)); // bottom xAxis scale prettify sd = new QwtScaleDraw; sd->setTickLength(QwtScaleDiv::MajorTick, 3); sd->enableComponent(QwtScaleDraw::Ticks, false); sd->enableComponent(QwtScaleDraw::Backbone, false); setAxisScaleDraw(xBottom, sd); setAxisTitle(xBottom, tr("Motor Unit, x")); setAxisMaxMinor(xBottom, 0); // 0.2 increments on bottom axis QwtValueList xtick[QwtScaleDiv::NTickTypes]; for (double i=0.0f; i<=1.0f; i+= 0.2) xtick[QwtScaleDiv::MajorTick]<<i; setAxisScaleDiv(xBottom,QwtScaleDiv(0.0f,1.0f,xtick)); // now color everything we created configChanged(CONFIG_APPEARANCE); // set to a 2 Normal Model setModel(2); // set mouse tracker parent->setMouseTracking(true); installEventFilter(parent); new muMouseTracker(this); }
/*! Update the axes scales \param intervals Scale intervals */ void QwtPlotRescaler::updateScales( QwtInterval intervals[QwtPlot::axisCnt] ) const { if ( d_data->inReplot >= 5 ) { return; } QwtPlot *plt = const_cast<QwtPlot *>( plot() ); const bool doReplot = plt->autoReplot(); plt->setAutoReplot( false ); for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ ) { if ( axis == referenceAxis() || aspectRatio( axis ) > 0.0 ) { double v1 = intervals[axis].minValue(); double v2 = intervals[axis].maxValue(); if ( !plt->axisScaleDiv( axis ).isIncreasing() ) qSwap( v1, v2 ); if ( d_data->inReplot >= 1 ) d_data->axisData[axis].scaleDiv = plt->axisScaleDiv( axis ); if ( d_data->inReplot >= 2 ) { QList<double> ticks[QwtScaleDiv::NTickTypes]; for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ ) ticks[i] = d_data->axisData[axis].scaleDiv.ticks( i ); plt->setAxisScaleDiv( axis, QwtScaleDiv( v1, v2, ticks ) ); } else { plt->setAxisScale( axis, v1, v2 ); } } } QwtPlotCanvas *canvas = qobject_cast<QwtPlotCanvas *>( plt->canvas() ); bool immediatePaint = false; if ( canvas ) { immediatePaint = canvas->testPaintAttribute( QwtPlotCanvas::ImmediatePaint ); canvas->setPaintAttribute( QwtPlotCanvas::ImmediatePaint, false ); } plt->setAutoReplot( doReplot ); d_data->inReplot++; plt->replot(); d_data->inReplot--; if ( canvas && immediatePaint ) { canvas->setPaintAttribute( QwtPlotCanvas::ImmediatePaint, true ); } }