Graphic adjustment when resizing a 3D Viewer

Did you ever find a solution for this?

Struggling like mad: the underlying opencascade view is being stretched to fit the new window size. Tried lots of attempts at forcing it back to position, but the Scale factors are always returning 1 before/after the resize - and attempt to reset them with SetAxialScale() (based on new window scale) isn't fixing it.

All that V3d_View does with camera on resize is basically updates it's aspect ratio V3d_View::MustBeResized() -> V3d_View::SetRatio() -> Graphic3d_Camera::SetAspect().

• When window's width is larger than height - visually changing width looks like view is fit vertically and expands/shrinks horizontally, changing height looks like zooming in/out view.
• When window's height is larger than width - visually changing height looks like view is fit horizontally and expands/shrinks vertically, changing width looks like zooming in/out view.

If the default behavior doesn't match your application needs, you may implement your own logic on window resizing by updating Graphic3d_Camera interface accessible via V3d_View::Camera().

Thanks for the reply - it helps!

Given what you've just said, I'm wondering if there is something going wrong with the underlying scaling calculations. Using example code...

void PaintGL()
{
    if (aViewSizeNew != aViewSizeOld)
    {
        aWindow->SetSize (aViewSizeNew.x(), aViewSizeNew.y());
        myView->MustBeResized();
        myView->Invalidate();

        aViewSizeOld = aViewSizeNew;
    }
}

(This is called for each resize event, so nothing else needed).
Then setting a fixed camera, Z-down:

      myView->SetProj(V3d_Zpos);
      myView->Zoom(-100,-100,+100,+100);

So, the main difference between the codebases is my Zoom() call. But - I would expect a zoom window to be respected on a rescale (wrt the canvas, not the window)? Instead, increasing the window size actually increases the zoom window, as opposed to either (a) ignoring it completely or (b) maintaining the zoom aspect. Easier to describe in pictures, attached. Even more annoying is that myView->Scale() doesn't change its value (3.82) upon a window resize event (despite the obvious change in scale in the view)

Once again I suspect its my misunderstanding somewhere - just doesn't seem to add up.

As an update to this, I've spent a lot of time wrapping view/camera code to correct both scaling and also an offset problem introduced by resizing.

The conclusion so that is that this is a QT6 / QOpenGlWidget / OpenGL problem. I came to this after correcting the camera/view, only to find:
a. got massive pixelation of objects after resizing upwards
b. there is an artifical offset introduced in-screen, whereby view point (0,0,0) no longer aligns to "reality" - e.g. my circular grid thinks its at 0, but view is reporting the At() position of 0 offset from where the grid thinks its at.

I suspect its a similar problem to this report: https://dev.opencascade.org/content/misalignment-issues-using-qt6

Think its a QT6 compatibility issue. Dunno how to fix it yet, slightly lost the will to live at the moment with this.

Hi,

Do you take the device pixel ratio into account when transferring mouse coordinates to occ?

double determineScreenScaleFactor(QScreen* screen)
{
    const int baseValue = 96;

    double dpi = screen->logicalDotsPerInch();
    double ratio = screen->devicePixelRatio();

    return dpi * ratio / baseValue;
}

const Graphic3d_Vec2i mousePosition(const QPointF& pt, double factor)
{
    return Graphic3d_Vec2i(pt.x() * factor, pt.y() * factor);
}

No, I didn't. Can you expand a little more on this?

If this is related just to mouse position then it won't help as I'm not getting as far as mouse input: just displaying a circular grid and watching it disappear off the side of the window when I resize!

You also need to factor in the correct size when the V3d_View requests the size of your Aspect_Window derived class. Something like.

void Qt_Window::Size(Standard_Integer& theWidth, Standard_Integer& theHeight) const
{
    QSize size = myWidget->size();
    QScreen* screen = myWidget->screen();

    // take hdpi monitors into account
    const int baseValue = 96;

    double dpi = screen->logicalDotsPerInch();
    double ratio = screen->devicePixelRatio();

    double factor = dpi * ratio / baseValue;

    theWidth = size.width() * factor;
    theHeight = size.height() * factor;
}

This might be needed working with hdpi screens or screens set with a custom scaling.

Solved it!

Well, worked around it...

Using QT >> OpenCascade code from here works a charm: https://github.com/mschollmeier/occQt6

I can't see any 'smoking guns' other than this code takes a fundamentally different approach to connecting QT6 to OCC