Problem using QwtPlotCanvas::paintCache();

[Javier]

Some additional information about paintCache().

If the instruction
QPixmap *pmGraf = grafCanvas.paintCache()
works, is easy to stream the plot. The following code could do it:

***********
<code>
QPixmap *pmGraf = grafCanvas.paintCache();
QImage image = pmGraf->toImage();
QFile outputFile;
if (!outputFile.open(stdout, QIODevice::WriteOnly))
{
cout << "outputFile did not open." <<endl;
}
QDataStream out(&outputFile);
out << image;
</code>
**************
If the output stream is redirected to a file,
my_application >> redirected_file.png
it can not be displayed. The reason is that
the file consists of the image with 4 extra bytes appended at the beginning.
If those 4 extra bytes are eliminated the image displays properly. I read a 16918 bytes
PNG image and streamed it out using a similar code as above . The redirected file was 16943 bytes long and it displayed properly with

tail -c 16939 redirectedfile.png | display


In the Qwt documentation I could not find any explanation why paintCache() returns a NULL pixmap. If some one knows please let me know.

[Javier]

There is really no problem with QwtPlotCanvas::paintCache() .

In my previous post I claimed having trouble using QwtPlotCanvas::paintCache() . Since this function is the only one that returns a QPixmap* in QwtPlotCanvas, I mistakenly assumed that this function is the one that fills the Pixmap with the contents of the plot. Studying the source files one finds that paintCache() only returns a pointer which may be NULL. And that is exactly what I was getting. As it turns out, the contents of the plot are grabbed in the function setPaintAttribute(), allthough the documentation only mentions that it changes the paint atrributes. Tried to use this function with no success, so I grabbed directly the contents.
<code>
const QRect qRC = grafScree->contentsRect();
cerr << "Plot contents rectangle. "<< qRC.x()<< " "<< qRC.y()<< " "<<qRC.width()<<" "<<qRC.height()<<endl;

// Create the PixMap
QPixmap cache = QPixmap(qRC.width(), qRC.height() );

if ( cache.isNull() ) cerr << "Pixmap not created."<<endl; else cerr << "Pixmap created."<<endl;
// Fill the Pixmap with the plot
cache = QPixmap::grabWidget(grafScree,
qRC.x(), qRC.y(), qRC.width(), qRC.height() );
//Also works: QPixmap cache = QPixmap::grabWindow(QApplication::desktop()->winId());
</code>

The whole idea of the exercise was to be able to stream to stdin the plot so that it will be piped to a second application thru stdin. The code to do it is:
<code>
// Change the Pixmap to an image that will be streamed out. (The Pixmap can be streamed out following the same procedure.)
const QImage imSal = cache.toImage();

QFile outputFile;
if (!outputFile.open(stdout, QIODevice::WriteOnly))
{
cerr << "Outputfile not opened" <<endl;
}
QDataStream out(&outputFile);
out << imSal;

</code>
It is important to remember that the output stream consists of the binary image with 4 bytes appended at the beginning. One easy way of getting rid of the first four bytes is using the tail command, For example, with
./streamplot | tail -c 10747 - | display
a 10751 byte stream is trimmed by tail to the last 10747 bytes (the image) and displayed by display .
The attachment contains streamplot.cpp , data file pru384.txt, the PNG image and the project file.:)

[Uwe]

The cache of the canvas is intended to speed up painting the content of the canvas for situations, where the content hasn't changed ( comparable to the backing store, but tailored for the situation of the Qwt framework ). But the cache is not intended for exporting the plot, what is pretty obvious as you will never see any axes.

Instead you have to use QwtPlot::print what is a much more powerful solution ( even comparable to QPixmap::grabWidget() ) as you can create scalable vector graphics in formats like SVG or PDF.

Uwe