Visualización científica con OpenGL y Qt

Question

Estoy tratando de escribir un programa de visualización OpenGL para algunos datos científicos usando Qt. Me gustaría poder usar mi programa existente sin cambios y simplemente poder llamar al glwidget y decirle que actualice los datos al final de cada paso de tiempo. Sin embargo, para ejecutar un programa Qt, parece que tiene que usar QApplication y luego qt.run () que bloquea la CPU.

Aquí está el pseudocódigo

main()

{
    ..set up stuff
    myVisualizer = new myGLWidget();

    for(int i=0;i<1000;i++)
    {
        ..do calculations
        myVisualizer.update(new data)
    }
}   

Me doy cuenta de que podría poner todo mi código existente en un QThread y hacer que envíe una señal cada vez que se realice para conectarse a una actualización. Sería más fácil de esta manera. ¿Alguien tiene una idea de cómo resolver esto?

Answer 1

Si realmente no desea investigar la solución roscada, que sería mejor, puede usar el tiempo de espera de caso especial con 0. Básicamente, cuando ejecuta un temporizador con un tiempo de espera de 0, ejecuta el código apropiado después de procesar los eventos que están actualmente en la cola de eventos. Entonces, podría configurar algo como esto:

class MyDialog : public QDialog
{
    Q_OBJECT
public:
    MyDialog()
    {
        m_step = 0;
        QTimer::singleShot( 0, this, SLOT( Process() ) );
    }

public slots:
    void Process() 
    {
        // do calculations
        m_step++;
        QTimer::singleShot( 0, this, SLOT( Redraw() ) );
        if ( m_step != 1000 )
            QTimer::singleShot( 0, this, SLOT( Process() ) );
    }

    void Redraw() { // do redrawing code here }

private:
    int m_steps;
};

Y luego combínelo con el código principal adecuado para Qt:

int main( int argc, char** argv )
{
    QApplication app( argc, argv );
    MyDialog dialog;
    dialog.show();
    return ( app.exec() );
}

Answer 2

Puede usar QThread en su aplicación y hacer los cálculos en un hilo separado. Lo que debe hacer es subclasificar el QThread e implementar el método run ().

Puede crear una clase de calculadora y agregar algunas señales en esa clase y conectar la señal a la ranura de actualización de su widget de visualización (en este caso QGLWidget :: updateGL ()).

Aquí hay un ejemplo aproximado: (Todo lo que tiene que hacer es crear un hilo y DisplayWidget en su función main () y configurar el DisplayWidget del hilo).

class Calculator: public QObject
{
     Q_OBJECT

     public:
        Calculator();
        void start();

    signals:
        void updateDisplayWidget(/* you can put the resulting data */);
};

class DisplayWidget(): public QGLWidget
{
     Q_OBJECT
     // override paint methods here
     public slots:
          void slotUpdateDisplayWidget(/* you can receive the resulting data*/);
};

class MyThread : public QThread
{
public:
    void run();
    void setDisplayWidget(DisplayWidget* displayWidget);

private:
    Calculator mCalculator;
};

void MyThread::run()
{
     mCalculator.start();
     exec();
}

MyThread::setDisplayWidget(DisplayWidget* displayWidget)
{
    displayWidget->moveToThread(this);
    connect(&mCalculator, SIGNAL(updateDisplayWidget()), displayWidget, SLOT(slotUpdateDisplayWidget()));
}