x-bottom scale div linked to pixels even if resizing

Hello,

I tried to make a fixed bottom axis (1 unit = 1 pixel), when resizing doesn't change scale but add/remove some units.

QwtPlot* m_pPlot;
QVector<QPointF> points; (sample)
QRectF m_BaseRec; (representing the actual unzoomed canvas rect)
QTimer timer; (simulate continuous data reception)

Code:

---

void Widget::resizeEvent(QResizeEvent *e) {
    if (m_pPlot->isVisible()) {
        QSize oldSize(e->oldSize());
        QSize size(e->size());
 
        if (points.size() >= m_BaseRec.width() && size.width() < oldSize.width()) {
            points.remove(0, oldSize.width() - size.width());
            m_BaseRec.moveRight(m_BaseRec.right()-m_pPlot->canvas()->width()+m_BaseRec.width());
        }
 
        m_BaseRec.setWidth(m_pPlot->canvas()->width());
        m_BaseRec.setHeight(m_pPlot->axisScaleDiv(QwtPlot::yLeft)->range());
    }
 
    if (timer.isActive()) {
        m_pPlot->setAxisScale(QwtPlot::xBottom, m_BaseRec.left(), m_BaseRec.right(), stepSize);
    }
 
    QWidget::resizeEvent(e);
}

---

But for this easy graphical purpose, it "flashes" a lot, always reploting. Is there a better way to do this ?
- reduce width push the last right point to stay against the right edge - the first and non-visible points are removed from the "points" vector
- increase width add empty space right to the last point

Help please ! There is several classes to manage axis scales and it's hard to understand specific "curve" vocabulary for me so i think i could miss something.

Check QwtPlotRescaler and the navigation example.

Uwe

One of the examples that I didn't study because I didn't understand (that it was about rescaling). Seems perfect, thx :)

Ok so, my code is cleaner using the right class. But it "flashes" again and I know why. I set the step size with setAxisScale at each new value, but when i call replot(), it auto-adjust the step size, then I set it again with the next value, then replot(), etc. Is there a way to fix this ?

This is my code, from a simple graphical QWidget project (with ui) if you want to test the behavior.

Widget.ui

Code:

---

<ui version="4.0">
 <class>Widget</class>
 <widget class="QWidget" name="Widget">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>706</width>
    <height>366</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Widget</string>
  </property>
  <layout class="QHBoxLayout" name="horizontalLayout">
   <item>
    <layout class="QVBoxLayout" name="verticalLayout">
     <property name="spacing">
      <number>0</number>
     </property>
     <item>
      <widget class="QPushButton" name="reset">
       <property name="text">
        <string>Stop</string>
       </property>
      </widget>
     </item>
    </layout>
   </item>
  </layout>
 </widget>
 <layoutdefault spacing="6" margin="11"/>
 <resources/>
 <connections/>
</ui>

---

Widget.h

Code:

---

#ifndef WIDGET_H
#define WIDGET_H
 
#include <QWidget>
#include <QTimer>
 
namespace Ui {
    class Widget;
}
 
class QSizeGrip;
class QwtPlot;
class QwtPlotGrid;
class QwtPlotCurve;
class PlotZoomer;
class QwtPlotMagnifier;
class QwtPlotPanner;
class QwtPlotRescaler;
 
class Widget : public QWidget
{
    Q_OBJECT
 
public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();
 
private:
    Ui::Widget *ui;
 
    QVector<QPointF> points;
    qreal curX;
    QTimer timer;
 
    QSizeGrip* m_pSizeGrip;
    QwtPlot* m_pPlot;
    QwtPlotCurve* m_pCurve;
    QwtPlotGrid* m_pGrid;
    int stepSize;
    PlotZoomer* m_pZoomer;
    QwtPlotMagnifier* m_pMagnifier;
    QwtPlotPanner* m_pPanner;
    QwtPlotRescaler* m_pRescaler;
 
    void resizeEvent(QResizeEvent *e);
 
private slots:
    void newValue();
    void playPause();
};
 
#endif // WIDGET_H

---

Widget.cpp

Code:

---

#include "Widget.h"
#include "ui_Widget.h"
 
#include <QTime>
#include <QSizeGrip>
#include <QResizeEvent>
#include <qmath.h>
 
#include <qwt_plot.h>
#include <qwt_plot_grid.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_canvas.h>
#include <qwt_plot_layout.h>
#include <qwt_plot_zoomer.h>
#include <qwt_plot_panner.h>
#include <qwt_plot_magnifier.h>
#include <qwt_plot_rescaler.h>
#include <qwt_scale_draw.h>
 
class PlotZoomer : public QwtPlotZoomer
{
public:
    explicit PlotZoomer(QwtPlotCanvas *canvas);
 
    void setZoomBase( const QRectF &base );
};
 
PlotZoomer::PlotZoomer(QwtPlotCanvas *canvas) :
    QwtPlotZoomer(canvas)
{
}
 
void PlotZoomer::setZoomBase(const QRectF &base)
{
    if ( !plot() )
        return;
 
    int currentIndex = zoomRectIndex();
    QStack<QRectF> stack = zoomStack();
    stack.replace(0, base);
    setZoomStack(stack, 0);
    zoom(currentIndex);
}
 
Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget),
    m_pSizeGrip(new QSizeGrip(this)),
    curX( 0 ),
    stepSize( 50 ),
    m_pPlot( new QwtPlot( this ) ),
    m_pCurve( new QwtPlotCurve ),
    m_pGrid( new QwtPlotGrid )
{
    ui->setupUi(this);
 
    m_pPlot->canvas()->setPaintAttribute(QwtPlotCanvas::BackingStore, false);
    m_pPlot->setCanvasBackground(Qt::black);
    m_pPlot->setWindowFlags( m_pPlot->windowFlags() | Qt::SubWindow );
    m_pPlot->plotLayout()->setAlignCanvasToScales(true);
 
    m_pRescaler = new QwtPlotRescaler(m_pPlot->canvas());
    m_pRescaler->setAspectRatio(QwtPlot::yLeft, 0.0);
 
    m_pSizeGrip->resize(12,12);
    m_pSizeGrip->move(width()-12,height()-12);
 
    m_pCurve->setPen(QColor(Qt::green));
    m_pCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
    m_pCurve->attach(m_pPlot);
 
    m_pGrid->setPen(QColor(Qt::white));
    m_pGrid->attach(m_pPlot);
 
    m_pZoomer = new PlotZoomer( m_pPlot->canvas() );
    m_pZoomer->setRubberBandPen(QColor(Qt::red));
    m_pZoomer->setTrackerPen( QColor( Qt::red ) );
    m_pZoomer->setTrackerFont( QFont( "Helvetica [Cronyx]", 12, QFont::Bold ) );
    m_pZoomer->setTrackerMode( PlotZoomer::AlwaysOn );
    m_pZoomer->setMousePattern( QwtEventPattern::MouseSelect2, Qt::RightButton, Qt::ControlModifier );
    m_pZoomer->setMousePattern( QwtEventPattern::MouseSelect3, Qt::RightButton );
 
    m_pMagnifier = new QwtPlotMagnifier( m_pPlot->canvas() );
    m_pMagnifier->setMouseButton( Qt::MidButton );
 
    m_pPanner = new QwtPlotPanner( m_pPlot->canvas() );
    m_pPanner->setMouseButton( Qt::LeftButton, Qt::ControlModifier );
 
    ui->verticalLayout->addWidget( m_pPlot );
 
    connect( &timer, SIGNAL( timeout() ), SLOT( newValue() ) );
    connect( ui->reset, SIGNAL( clicked() ), SLOT( playPause() ) );
 
    qsrand( QTime::currentTime().msec() );
    playPause();
}
 
Widget::~Widget()
{
    delete ui;
}
 
void Widget::newValue()
{
    points << QPointF(curX++, qSin(curX/30)*100);//qrand()%201 - 100);
 
    if (points.size() > m_pPlot->canvas()->width()) {
        m_pRescaler->setExpandingDirection(QwtPlotRescaler::ExpandDown);
        points.remove(0);
    }
 
    int left (curX > points.size() ? curX - points.size() : 0);
    m_pPlot->setAxisScale(QwtPlot::xBottom, left, left + m_pPlot->canvas()->width(), stepSize);
 
    m_pCurve->setSamples(points);
    m_pPlot->replot();
}
 
void Widget::playPause() {
    bool wasActive(timer.isActive());
 
    m_pZoomer->setEnabled(wasActive);
    m_pMagnifier->setEnabled(wasActive);
    m_pPanner->setEnabled(wasActive);
    m_pPlot->axisScaleDraw(QwtPlot::xBottom)->enableComponent(QwtAbstractScaleDraw::Labels, wasActive);
 
    if (!wasActive) {
        m_pZoomer->zoom(0);
        ui->reset->setText("Stop");
        points.clear();
        curX = 0;
        m_pPlot->setAxisScale(QwtPlot::xBottom, 0, m_pPlot->canvas()->width(), stepSize);
        m_pPlot->setAxisScale(QwtPlot::yLeft, 0, 0, 0);
        m_pPlot->setAxisAutoScale(QwtPlot::yLeft);
        m_pPlot->setContentsMargins(0,0,0,15);
        timer.start(20);
    } else {
        timer.stop();
        ui->reset->setText("Start");
        m_pZoomer->setZoomBase(QRectF(m_pPlot->axisScaleDiv(QwtPlot::xBottom)->lowerBound(), m_pPlot->axisScaleDiv(QwtPlot::yLeft)->lowerBound(), m_pPlot->axisScaleDiv(QwtPlot::xBottom)->range(), m_pPlot->axisScaleDiv(QwtPlot::yLeft)->range()));
        m_pPlot->setContentsMargins(0,0,0,0);
        m_pPlot->replot();
    }
}
 
void Widget::resizeEvent(QResizeEvent *e) {
    QWidget::resizeEvent(e);
    if (m_pPlot->isVisible()) {
        QSize oldSize(e->oldSize());
        QSize size(e->size());
 
        if (points.size() >= m_pPlot->canvas()->width() && size.width() < oldSize.width()) {
            m_pRescaler->setExpandingDirection(QwtPlotRescaler::ExpandDown);
            points.remove(0, oldSize.width() - size.width());
        } else {
            m_pRescaler->setExpandingDirection(QwtPlotRescaler::ExpandUp);
        }
    }
 
    m_pSizeGrip->move(width()-12, height()-12);
}

---

Another strange behavior: after zooming with a box (when it is paused), unzooming with right click one more time than the 0 level do a one-pixel horizontal shift... A way to avoid this ?

Edit: And I can't reduce the vertical size as much as I want...

I think I should increase the max number of steps and only it, I don't know how. I tried

Code:

---

double x1(0.0), x2(0.0), step(stepSize); // I don't care about these parameters...
m_pPlot->axisScaleEngine(QwtPlot::xBottom)->autoScale(1000, x1, x2, step);

---

=> no change.

Edit : it is something like setAxisMaxMajor (because it's good when the width is smaller than 8 steps), but setting it is like setting a low limit to rescaling :/

I didn't get what your request is about in detail and posting even more code won't make things clearer.

Better build a small (!) demo application I can compile and run on my system.

Uwe

It really is a small demo (it only build a curve with data simulation and start/stop button), as I said if you create a graphical QWidget default project in Qt Creator (with main.cpp, Widget.h, Widget.cpp and Widget.ui) and copy-paste this code, you should run my work and see what I mean. I attach the project (.zip).

Then just rescale and you will see the fight between my setAxisScale(...,stepSize) and the axisMaxMajor at each replot().

Code:

---

void Widget::newValue()
{
    points << QPointF(curX++, qSin(curX/30)*100);
 
    if (points.size() > m_pPlot->canvas()->width()) {
        m_pRescaler->setExpandingDirection(QwtPlotRescaler::ExpandDown);
        points.remove(0);
    }
 
    int left (curX > points.size() ? curX - points.size() : 0);
    m_pPlot->setAxisScale(QwtPlot::xBottom, left, left + m_pPlot->canvas()->width(), stepSize);
 
    m_pCurve->setSamples(points);
    m_pPlot->replot();
}

---

I fixed it by adding this code in resizeEvent:

Code:

---

if (timer.isActive()) {
    m_pPlot->setAxisMaxMajor( QwtPlot::xBottom, m_pPlot->canvas()->width() / stepSize + 1 );
}

---

I fix the resizing comportment when paused too. See new attachment. The comportment is good, but maybe not optimized using the good tools... There are some one-pixel shifts again, not with unzooming (fixed too but I don't know why), but with resizing again.

The last, big, problem is the "pause" mode.

Code:

---

timer.stop();
ui->reset->setText("Start");
m_pZoomer->setZoomBase(QRectF(m_pPlot->axisScaleDiv(QwtPlot::xBottom)->lowerBound(), m_pPlot->axisScaleDiv(QwtPlot::yLeft)->lowerBound(), m_pPlot->axisScaleDiv(QwtPlot::xBottom)->range(), m_pPlot->axisScaleDiv(QwtPlot::yLeft)->range()));
m_pRescaler->setRescalePolicy(QwtPlotRescaler::Fixed);
m_pPlot->setContentsMargins(0,0,0,0);
m_pPlot->replot();

---

It forces a low limit to resize, and often increase the size of the curve when pausing, if it is too small.

Sorry again for my bad english (rescale != resize ?), I hope you understand the main points...

Edit: It is because of m_pPlot->setContentsMargins(0,0,0,0); . But I chose to not display bottom tick labels when playing because numbers are not clipped and make the plot trembling. And to just hide/show, a margin is necessary when hidden, otherwise it resizes the canvas. So I know the cause but not the solution, you can help me :) Then you can add it to Qwt examples :D