GLwidget GraphicScene size problem

gfxx

I at all, I revised my old app in Qt4.8 for upgrade it to 5.12 on linux.

in my MainWindows i have a GlWidget for render an opencv video.

           ui->glwidget->setGeometry(450, 20, 450, 400);

           QRectF MatrixRect(QPoint(450, 20), QSize(450, 400));

           sceneMatrix = new QGraphicsScene(this);
           sceneMatrix->setSceneRect(MatrixRect);

I have subclass QGLwidget in these manner (heather):

#include .....
#include <QPaintDevice>
#include <QPainter>


class glwidg : public QGLWidget
{
    Q_OBJECT

public:
    explicit glwidg(QWidget *parent = 0);
    static cv::Point SendMousePoint;
    static int xsend;
    static int ysend;






signals:
    void imma_orig(QImage qi1);
    void MousePoint(cv::Point MousePt);




    
public slots:

   // void camera01(QImage camera00);
     //void sendImage(cv::Mat* img);
     //void Mat22QImage(cv::Mat imma);
     void donextcam();
     void imma_orig_r1(QImage qi1);
     void stopcam1(bool st1);




private:
     QImage qqframe;
     QImage qq1frame;
     QImage qq2frame;
     QTimer *tim;
     static int xAtPress, yAtPress;


protected:
    void resizeGL(int w, int h);
    void initializeGL();
    void paintGL();
    void updateScene();
    void renderImage();
    void mouseMoveEvent(QMouseEvent * event);
    
};

#endif // GLWIDG_H

And cpp file:

#include "mainwindow.h"
#include "ui_mainwindow.h"

#include "glwidg.h"

#include <QThread>
#include <QtCore>
#include <QtConcurrent/QtConcurrent>
#include <QtConcurrent/QtConcurrentRun>
#include <QFuture>
#include <QFutureWatcher>
#include <QtWidgets>
#include <QtWidgets/QAction>
#include <QtWidgets/QWidget>
#include <QtWidgets/QWidgetAction>
#include <QtWidgetsDepends>
#include <QtWidgetsVersion>
#include <QTableWidget>
#include <QTableWidgetItem>
#include <QTableWidgetSelectionRange>
#include <QTableView>

#include <opencv2/opencv.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/core/core.hpp>
#include <sstream>
#include <string.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <GL/freeglut.h>
#include <QtOpenGL/QGLWidget>
//#include <QtGui>
#include <QtOpenGL/QGLBuffer>
#include <QtOpenGL/QtOpenGL>
#include <QTime>
#include <QTimer>
#include <QDebug>


QImage camera000;
GLuint texture[1];
QImage GL_formatt;
QImage qform;
QImage qform1;
int cambio1 = 0;

//cv::Mat imma;
cv::Mat imma2;
cv::Mat imma3;

int play = 0;


glwidg::glwidg(QWidget *parent) :
    QGLWidget(parent)

{

    this->setAttribute(Qt::WA_DeleteOnClose);

    QGLWidget(QGLFormat(QGL::DirectRendering));
    setMaximumSize(480,360);//(352,288);
    setMinimumSize(480,360);


    initializeGL();
    //resizeGL(480,360);
    paintGL();


}

int glwidg::xAtPress = 0;
int glwidg::yAtPress = 0;
int glwidg::xsend = 0;
int glwidg::ysend = 0;
cv::Point glwidg::SendMousePoint(0,0);


void glwidg::mouseMoveEvent(QMouseEvent * event)
{


    xAtPress = event->x();
    yAtPress = event->y();
    xsend = round(xAtPress*1.422222222);
    ysend = round(yAtPress*1.2);
   /* if (xsend < 0) {xsend = 0;}
    if (xsend > 640) {xsend = 640;}
    if (ysend < 0) {ysend = 0;}
    if (ysend > 480) {ysend = 480;}*/
    SendMousePoint = cv::Point(xsend, ysend);
    emit MousePoint(SendMousePoint);
    //qDebug() << "Mausepoint glwidg: " << SendMousePoint.x << ", " << SendMousePoint.y;
}


void glwidg::resizeGL(int w, int h)
{

    makeCurrent();
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, w, 0, h); // set origin to bottom left corner
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();


}


void glwidg::initializeGL()
{
    makeCurrent();
    glClearDepth(2000.0);
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_COLOR_MATERIAL);
    glEnable(GL_BLEND);
    glEnable(GL_POLYGON_SMOOTH);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    qglClearColor(Qt::white);



}

void glwidg::paintGL()
{
    makeCurrent();


    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    qglColor(Qt::white);


    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
    glMatrixMode(GL_MODELVIEW); /*+*/
    glEnable(GL_DEPTH_TEST);


    if (cambio1 == 0)
    {
        qform1.load("/home/myImage.png");
        qq1frame = qform1.scaled(this->size(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
    }
    else
    {
        qq1frame = qform1.scaled(this->size(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
    }


    //qq1frame.load("/home/myImage.png");
    qqframe = qq1frame.mirrored(false, true);

    if(!qqframe.isNull())
    {
        qqframe = qqframe.scaled(this->size(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
       // glDrawPixels(qqframe.width(), qqframe.height(), GL_RGBA, GL_UNSIGNED_BYTE, qqframe.bits());

        // or do 2D texture mapping
        glMatrixMode(GL_MODELVIEW); /**/
        glEnable(GL_DEPTH_TEST);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0,qqframe.width(),qqframe.height(),0);
        glMatrixMode(GL_MODELVIEW);
        //glDisable(GL_DEPTH_TEST);
        glLoadIdentity();
        glEnable(GL_TEXTURE_2D);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexImage2D( GL_TEXTURE_2D, 0, 4, qqframe.width(), qqframe.height(), 0, GL_BGRA, GL_UNSIGNED_BYTE, qqframe.bits() );
        glBegin(GL_QUADS);
        glTexCoord2f(0,0); glVertex2f(0,qqframe.height());
        glTexCoord2f(0,1); glVertex2f(0,0);
        glTexCoord2f(1,1); glVertex2f(qqframe.width(),0);
        glTexCoord2f(1,0); glVertex2f(qqframe.width(),qqframe.height());
        glEnd();
        glDisable(GL_TEXTURE_2D);
        // .... end

       // qDebug() << ("ho disegnato??");
        glDisable(GL_DEPTH_TEST);


        glFlush();

     }

    if(qqframe.isNull())
    {
        glClear(GL_COLOR_BUFFER_BIT);
        qglColor(Qt::white);
    }

    qDebug() << "x:   " << qqframe.width() << "y:   " << qqframe.height();

/* AT THESE POINT.... FIRST TIME I SEE RIGHT SIZE OF IMAGE 480*360 .... AFTER THESE I SEE ONLY 100*30 .... TOO LITTLE */

}


void glwidg::donextcam()
{

    makeCurrent();


}


void glwidg::imma_orig_r1(QImage qi1)
{
    cambio1 = 1;
    qform1 = qi1;
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    updateGL();

}

void glwidg::stopcam1(bool st1)
{
    if (st1)
    {
        cambio1 = 0;
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        updateGL();
    }
    else
    {
        cambio1 = 1;
    }
}

/* AT THESE POINT.... FIRST TIME I SEE RIGHT SIZE OF IMAGE 480360 .... AFTER THESE I SEE ONLY 10030 .... TOO LITTLE */

These my problem .... sems that scene become real screen of GLwidget so it haa automatic resize .... but not know why.

Regards
gfxx

SGaist

Hi,

Why are you calling initializeGL and paintGL from your constructor ? These are called automatically when appropriate by Qt.

gfxx

@SGaist Really because in old Qt4.8 version it work .... witouth not work. But just now I try your suggest and obtain only X=100 and Y=30 instead 480x360 as in the past ..... I'm a little confused about ....

gfxx

@gfxx Ok I try to convert my code in more new one using QOpenGLWidget isnstead of QGLWidget ....

gfxx

@gfxx Problem is Portability related ... when change my class into QOpenGLwidget from QGLWidget all work fine.

regards