Hi @f.serreau
I have tested your example, and it works correctly with no errors.
I tested it on Windows 10 (Fall Update), MS VS2017 and Qt 5.11.0.

Sorry, I don't have the XPS printer available. Can you check whether you have the same result with the QPdfWriter class ?

@mdma2
Can you post the full code of this short example, so that it can be tried out immediately using simple copy/paste...

In your MyView::paintEvent write QPainter painter(viewport()); instead of QPainter painter(this);.

@dalishi
You should not mix painter and gl calls like that. You should put gl calls between calls to beginNativePainting() and endNativePainting(), which are painter functions. It might also help to save the painter state before and restore it after depending on how it messes up your gl stuff.
the docs here tell you what the painter does to the states.

Ok, I will try that...
Maybe I should have been more clearly what I intend to get...
I had it all working already, just without the scaling issue

I get camera images and I let opencv compute min/max values and a centerpoint. Somethimes the camera is rotated in a undesired position so the user should be able to rotate the view, including the measurepoints, and more complex including the point values so that the stay at the points but do not rotate staying readable...

I keep trying with qpainter draw

@VRonin Yes, they are, but the pixmap is just grabbed QGraphicsView's content using grab() method.

@mrjj Thanks! I'll look into that. I got another reply from stackoverflow which I will also give a shot. I'll keep everyone in both forums posted as soon as I have some results.

Hi,

Glad you found out and thanks for sharing !

What version of Qt are you using ?
On which platform ?
Did you check the bug report system to see if it's something known ?

It uses the raster engine. See here for historical informations.

The following solution worked:

#include "mainwindow.h" #include "ui_mainwindow.h" MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); } MainWindow::~MainWindow() { delete ui; } void MainWindow::paintEvent(QPaintEvent *event) { QPainter painter(this); QFont font = painter.font (); font.setFamily ("Arial"); font.setPixelSize (25); painter.setFont (font); painter.setPen (Qt::white); QRect rect(100, 120, 200, 50); painter.setBrush (Qt::blue); painter.drawRect (rect); painter.drawText (rect, Qt::AlignCenter, tr("Record deleted.")); painter.end(); QTimer::singleShot(3000,this,&MainWindow::hideRect); update(); }

Thank you for your help.

Yeah i feel like i do sudo apt-get update && upgrade at least once a day. I just checked about SIP and i compiled it from source but i cant remember if i actually used the command make and make install. Does that mean i have to reinstall pyqt5 again? I guess i just open a new thread. Thanks for all the help @SGaist

I have found a solution that kind of does the job, although takes three times as much memory.
Every update I calculate the difference between the new and the old saturation matrix, this eliminates 60% of the nonzero values, which means it gets drawn that much faster.

As a second layer of optimization I call repaint with a rectangle describing the most important zone, and call update every 60ms.

@joeQ
As per your suggesttion i'll make changes in the code on my own.Once again thanks for your help.

Not all paint devices (widgets, images, etc) support all composition modes. QImage does, but QWidget might not, which is what I suppose is happening here.

@VRonin Depends on what he wants to achieve.
Is it a widget, than I agree with you.
Is it some CAD-drawing (looks like a diagram symbol to me), then I would prefer drawing.
For the latter the Graphics View Framework would be more practical though.

Thanx, it really solved my problem

@pauledd
:)
class MyWidget : public QWidget << yes that is subclassing :)

Also, a widget can only paint on it self.
its not possible to paint on other widget from inside a
paintevent.
Thats why the first sample didnt work. You asked painter to paint on tab from inside mainwindows paintEvent :)
I guess you already found out but its just to make clear for other readers.

Hi,

You should check the bug report system to see if it's something known. If not please consider opening a new report providing your example and as many details as possible about your setup.

@mrjj
Yeah make sense.

Thanks!

OK, so now that I have launched the program with admin rights and came back with user session, the application is working (?!?)

So it was neither a DLL or plugins problem, but just a weird right access blocking. I am sad I can't explain why I had to launch it once with admin session, but at least I am glad I solved my problem.

Thanks anyway to those who give their time to help.

@Walux :-)

There are a couple of errors here and some weird unused code. Lets go over it:

setGeometry: Unable to set geometry (...) - this is just a warning. A widget has a 0 minimum size and minimum size hint by default. You used a layout on it so it has some margins (11 px in this case) Because of the frame of the window a window manager can't create a window that small so it resizes it to a smallest possible size and lets you know with a warning. To fix it either use setMinimumSize() or override minimumSizeHintfor your widget.

QPainter related messages - you're creating a painter as a class member variable. Don't do that. Create the painter locally in the paint event with a proper surface to use it on:

void DrawLine::paintEvent(QPaintEvent *) { QPainter p(this); //paint using p ...

There's no such thing as a lineEvent() - what is that?

What's the layout for? Are you gonna put something in it? If yes then remember that it will obscure whatever you paint in your paint event.

You're not deleting the dLine variable in main(). It's leaking. Either create it on the stack (which is the easiest and recommended), set a Qt::WA_DeleteOnClose attribute on it or delete it manually after the a.exec() call returns (pointless manual work).

just a hint - when overriding virtual methods use override specifier. It will save you a lot of typo related bugs:

void paintEvent(QPaintEvent *); //compiles fine and overrides the base implementation void pAintEvent(QPaintEvent *); //compiles fine and never gets called because of a typo void pAintEvent(QPaintEvent *) override; //doesn't compile and lets you know. yay!

@kevin32 Great :)

@AlvaroS
ok. seems a bit messy.
Do you really need a QGraphicsScene then ?
You could also draw it as a custom control. you need zooming etc ?

In any case, did u see this example
http://doc.qt.io/qt-5/qtwidgets-graphicsview-diagramscene-example.html

it even has arrowhead class :)

@kshegunov

Awesome! I'll give it a try!

Ok I found the answer. I added
setAttribute(Qt::WA_PaintOutsidePaintEvent, true);
flag to the widget I am repainting

@jsulm There're no calls to paintEvent() or update() inside updateGL()

void OpenGLWidget::updateGL() { makeCurrent(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); //LEQUAL glEnable(GL_CULL_FACE); glFrontFace(GL_CW); glLineWidth(1.0f); // glDisable(GL_DITHER); glEnable(GL_LINE_SMOOTH); glEnable(GL_MULTISAMPLE); glViewport(0,0,m_width , m_height); m_camera = m_cameraController.toMatrix(); QVector3D lightDirection; switch (m_currView) { case TopView: lightDirection = QVector3D(0.0,0.0,1.0); break; case BottomView: lightDirection = QVector3D(0.0,0.0,-1.0); break; case LeftView: lightDirection = QVector3D(-1.0,0.0,0.0); break; case RightView: lightDirection = QVector3D(1.0,0.0,0.0); break; case FrontView: lightDirection = QVector3D(0.0,-1.0,0.0); break; case BackView: lightDirection = QVector3D(0.0,1.0,0.0); break; } lightDirection.normalize(); QVector3D directionalColor = QVector3D(0.3,0.3,0.3); QVector3D ambientLight = QVector3D(0.5,0.5,0.5); m_world.setToIdentity(); m_world.translate(m_modelBox.getCenterPoint()); m_world.rotate(m_rotation); m_world.scale(1.0f, 1.0f, m_worldZScalar); m_world.translate(-m_modelBox.getCenterPoint()); QMatrix3x3 normalMatrix = m_world.normalMatrix(); if(geometries){ if(!m_drawWireFrame){ m_programGrid->bind(); //Set MVP Uniforms m_programGrid->setUniformValue(m_projMatrixLoc, m_proj); m_programGrid->setUniformValue(m_mvMatrixLoc, m_camera * m_world); m_programGrid->setUniformValue(m_normalMatrixLoc, normalMatrix); //Set Lighting Uniforms. m_programGrid->setUniformValue(m_lightDirectionLoc, lightDirection); m_programGrid->setUniformValue(m_directionalColorLoc, directionalColor); m_programGrid->setUniformValue(m_ambientColorLoc, ambientLight); //Draw Grid Geometry geometries->drawGeometry(m_programGrid); m_programGrid->release(); //Draw Border Lines if(m_showBorders){ m_programLines->bind(); m_programLines->setUniformValue(m_projMatrixLocLines, m_proj); m_programLines->setUniformValue(m_mvMatrixLocLines, m_camera * m_world); geometries->drawLines(m_programLines, QVector3D(0.0,0.0,0.0)); m_programLines->release(); } }else{ m_programLines->bind(); m_programLines->setUniformValue(m_projMatrixLocLines, m_proj); m_programLines->setUniformValue(m_mvMatrixLocLines, m_camera * m_world); geometries->drawLines(m_programLines, QVector3D(1.0,1.0,1.0)); m_programLines->release(); } } if(wellgeometries){ glLineWidth(4.0f); m_programLines->bind(); m_programLines->setUniformValue(m_projMatrixLocLines, m_proj); m_programLines->setUniformValue(m_mvMatrixLocLines, m_camera * m_world); wellgeometries->drawLines(m_programLines, QVector3D(1.0,0.0,0.0)); m_programLines->release(); } if(m_showCompass){ glDisable(GL_DEPTH_TEST); glViewport(0,0,100,100); m_world.setToIdentity(); m_world.translate(0,0,-5); m_world.rotate(m_cameraController.rotation().inverted()); m_world.rotate(m_rotation); QMatrix4x4 proj; // Set near plane, far plane , field of view const qreal zNear = 1.0f, zFar = 150.0f, fov = 45.0; proj.setToIdentity(); proj.perspective(fov, 1.0f, zNear, zFar); m_programGrid->bind(); m_programGrid->setUniformValue(m_projMatrixLoc, proj); m_programGrid->setUniformValue(m_mvMatrixLoc, m_world); m_programGrid->setUniformValue(m_normalMatrixLoc, normalMatrix); //Set Lighting Uniforms. m_programGrid->setUniformValue(m_lightDirectionLoc, lightDirection); m_programGrid->setUniformValue(m_directionalColorLoc, directionalColor); m_programGrid->setUniformValue(m_ambientColorLoc, ambientLight); compass->drawCompassGeometry(m_programGrid); m_programGrid->release(); } //doneCurrent(); }

@mrjj yeah!! its working bro if i remove label.. Thank you all for your suggestions

@Joel-Bodenmann
You are very welcome.
I hope it will work as fine as I imagine :)

Good luck and happy coding !

It's not very well exposed, but this is actually documented in QPainter::begin():

Warning: A paint device can only be painted by one painter at a time.

Ok, I think you're going deeper and deeper into the woods but it's a totally bad direction.
So if I'm getting this right you are making some algorithm that does stuff (sorting?) to some items represented by rectangles and you want to visualize the steps. Is that right?
In that case setting up hardcoded timers and single shots is going against the wind because you're effectively tying to predict the whole thing and set timers for it. That's just gonna give you a headache and you won't know what you did the next day.

Step back and look at the problem. You've got some algorithm that operates on an array. Conceptually:

while(!done()) { doAnotherStep(); }

Now you want to visualize the steps, conceptually:

while(!done()) { doAnotherStep(); visualizeTheStep(); }

The problem is that the visualization should take time, so this approach is not gonna work. What you need to do is make it event driven, i.e. conceptually:

stepEnded -> visualize visualizationEnded -> done ? exit : doAnotherStep

For this you can use the signal/slot mechanism of Qt. Make a class that does the algorithm and has a step method. At the end of the method emit a signal. Make another class for visualization and give it a visualize method. At the end of it emit a signal. Then just connect the two.

Rough concept:

class Algo : public QObject { Q_OBJECT public: Algo(Vector<stuff>* data) : dataPtr(data) {} bool done() { return /* check if more steps needed */ } void doStep() { /* do stuff to dataPtr */; emit stepFinished(someStuffToSwap, someOtherStuffToSwap); } signal: void stepFinished(stuff* item1, stuff* item2); private: Vector<stuff>* dataPtr; }; class Vis : public QObject { Q_OBJECT public: Vis(Vector<stuff>* data) { /*create graphics items and whatnot */ } void visualizeStep(stuff* item1, stuff* item2) { /* do the animations here and emit finished() when they're done*/ } signals: void finished(); }; //and then you can use it like this: Vector<stuff> data = ... Algo algo(&data); Vis vis(&data); connect(algo, &Algo::stepFinished, vis, &Vis::visualizeStep); connect(vis, &Vis::finished(), [&]{ if(!algo.done()) algo.doStep(); }); algo.doStep(); /start the first step

Please share any bug report you are opening so that other may find them more easily.

You should also set the height you want on the QmQTargetCanvas instance.

It's bananas to me that Qt doesn't have a composition mode that multiplies the alpha channels together.

Of course it does. At least couple of modes do that. But they do it in a more sensible way.

Multiplying values channel wise is a very weird operation when you talk about colors and I haven't seen it in any graphics API. You could argue that multiplying alphas has some sense in some situations, but color channels? To put it simply: what does "red times red" mean? That's the bananas. You might be getting something that you like by accident but it has little sense computationally. In most common composition modes you mix color channels with alpha values in one form or another.

eg. if you want to make the original image more transparent)

If you want to apply source alpha to the destination you would multiply the source alpha channel with the destination color channels, not its alpha channel alone. That's what for example QPainter::CompositionMode_DestinationIn mode does.