Tornado-Visualization/datenvisualisierung_sose2024/opengldisplaywidget.cpp

#include "opengldisplaywidget.h"
#include <QMouseEvent>
#include <QKeyEvent>
#include <QOpenGLFunctions>
#include <iostream>
#include "math.h"
#include "cartesiangridtohorizontalslicefilter.h"
#include "horizontalslicetoimagemapper.h"
#include "horizontalslicerenderer.h"
#include "flowdatasource.h"


// Define grid size here
#define XValue 16
#define YValue 16
#define ZValue 16

OpenGLDisplayWidget::OpenGLDisplayWidget(QWidget *parent)
    : QOpenGLWidget(parent),
      distanceToCamera(-8.0)
{
    setFocusPolicy(Qt::StrongFocus);
    animate = false;
    timey = new QTimer(this);
    connect(timey, &QTimer::timeout, this, QOverload<>::of(&OpenGLDisplayWidget::animateVisual));
}


OpenGLDisplayWidget::~OpenGLDisplayWidget()
{
    // Cleans up visualization pipeline
    //delete bboxRenderer;
    delete grid;
    delete filter;
    delete mapper;
    delete renderer;
    delete contourrenderer;
    delete streamlinemapper;
    delete streamlinerenderer;
    // ....
}


QString OpenGLDisplayWidget::openGLString()
{
    QString profileStr;
    switch (format().profile())
    {
    case QSurfaceFormat::NoProfile:
        profileStr = "no profile";
        break;
    case QSurfaceFormat::CompatibilityProfile:
        profileStr = "compatibility profile";
        break;
    case QSurfaceFormat::CoreProfile:
        profileStr = "core profile";
        break;
    }

    return QString("%1.%2 (%3)").arg(format().majorVersion())
            .arg(format().minorVersion()).arg(profileStr);
}


void OpenGLDisplayWidget::initializeGL()
{
    // Query and display some information about the used OpenGL context.
    std::cout << "Initializing OpenGLDisplayWidget with OpenGL version "
              <<  openGLString().toStdString() << ".\n" << std::flush;

    // Set the backgound color of the OpenGL display enable the depth buffer.
    QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
    f->glClearColor(0, 0, 0, 1);
    f->glEnable(GL_DEPTH_TEST);

    // Our own initialization of the visualization pipeline.
    initVisualizationPipeline();
}


void OpenGLDisplayWidget::resizeGL(int w, int h)
{
    // Calculate aspect ratio of the current viewport.
    float aspectRatio = float(w) / std::max(1, h);

    // Reset projection and set new perspective projection.
    projectionMatrix.setToIdentity();
    projectionMatrix.perspective(45.0, aspectRatio, 0.05, 25.0);

    // Update model-view-projection matrix with new projection.
    updateMVPMatrix();
}


void OpenGLDisplayWidget::paintGL()
{
    // Clear color and depth buffer.
    QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
    f->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Calls renderer modules
    //bboxRenderer->drawBoundingBox(mvpMatrix);
    renderer->drawBoundingBox(mvpMatrix);
    renderer->drawFrame(mvpMatrix);
    renderer->drawImage(mvpMatrix);
    contourrenderer->draw(mvpMatrix);
    streamlinerenderer->draw(mvpMatrix);
    // ....
}


void OpenGLDisplayWidget::mousePressEvent(QMouseEvent *e)
{
    // Save the current position of the mouse pointer for subsequent use
    // in mouseMoveEvent().
    lastMousePosition = QVector2D(e->localPos());
}


void OpenGLDisplayWidget::mouseMoveEvent(QMouseEvent *e)
{
    // If the user holds the left mouse button while moving the mouse, update
    // the rotation angles that specify from which side the grid visualization
    // is viewed.
    if (e->buttons() & Qt::LeftButton)
    {
        // Vector that points from the last stored position of the mouse
        // pointer to the current position.
        QVector2D mousePosDifference = QVector2D(e->localPos()) - lastMousePosition;

        // Update rotation angles in x and y direction. The factor "10" is an
        // arbitrary scaling constant that controls the sensitivity of the
        // mouse.
        rotationAngles.setX(
                    fmod(rotationAngles.x() + mousePosDifference.x()/10.,
                         360.));
        rotationAngles.setY(
                    fmod(rotationAngles.y() + mousePosDifference.y()/10.,
                         360.));

        // Store current position of mouse pointer for next call to this method.
        lastMousePosition = QVector2D(e->localPos());

        // Update model-view-projection matrix with new rotation angles.
        updateMVPMatrix();

        // Redraw OpenGL.
        update();
    }
}

void OpenGLDisplayWidget::wheelEvent(QWheelEvent *e)
{
    // Update distance of the camera to the rendered visualization. The factor
    // "500" is arbitrary and controls that sensitivity of the mouse.
    distanceToCamera += e->delta() / 500.;

    // Update model-view-projection matrix with new distance to camera.
    updateMVPMatrix();

    // Redraw OpenGL.
    update();
}


void OpenGLDisplayWidget::keyPressEvent(QKeyEvent *e)
{
    // This function looks for key presses and then executes the corresponding command
    // up and down move the slice up and down
    // x,y,z and m activate various wind components or display the magnitude
    // note that we only need to change the i in the Filter pointer, which is why
    // this implementation should be fast
    // Space starts an animation (implemented with a timer)
    // R resets the time
    // left and right enable the user to check specific times

    if (e->key() == Qt::Key_Up)
    {
        if (renderer->z < ZValue -1) {
            renderer->moveSlice(1);
            filter->setSlice(renderer->z);
            mapper->getSlice(filter->passSlice(XValue,YValue));
            contourmapper->newZ(filter->passSlice(XValue,YValue), renderer->z);
        }
    }
    else if (e->key() == Qt::Key_Down)
    {
        if (renderer->z > 0) {
            renderer->moveSlice(-1);
            filter->setSlice(renderer->z);
            mapper->getSlice(filter->passSlice(XValue,YValue));
            contourmapper->newZ(filter->passSlice(XValue,YValue), renderer->z);
        }
    } else if (e->key() == Qt::Key_X) {
        mapper->setMagnitude(false);
        contourmapper->setMagnitude(false);
        filter->changeWindComponent(0);
        mapper->getSlice(filter->passSlice(XValue,YValue));
        contourmapper->newZ(filter->passSlice(XValue,YValue), renderer->z);
    } else if (e->key() == Qt::Key_Y) {
        mapper->setMagnitude(false);
        contourmapper->setMagnitude(false);
        filter->changeWindComponent(1);
        mapper->getSlice(filter->passSlice(XValue,YValue));
        contourmapper->newZ(filter->passSlice(XValue,YValue), renderer->z);
    } else if (e->key() == Qt::Key_Z) {
        mapper->setMagnitude(false);
        contourmapper->setMagnitude(false);
        filter->changeWindComponent(2);
        mapper->getSlice(filter->passSlice(XValue,YValue));
        contourmapper->newZ(filter->passSlice(XValue,YValue), renderer->z);
    } else if (e->key() == Qt::Key_M) {
        // SPECIAL CASE
        filter->changeWindComponent(0);
        mapper->getSlice(filter->passSlice(XValue,YValue));
        mapper->setMagnitude(true);
        contourmapper->setMagnitude(true);
    } else if (e->key() == Qt::Key_Right) {
        std::cout << "Right press\n";
        grid->updateT();
    } else if (e->key() == Qt::Key_Left) {
        grid->decreaseT();
    } else if (e->key() == Qt::Key_Space) {
        if (!animate) {
            animate = !animate;
            timey->start(34); // 30Hz/FPS
            std::cout << "Animation started\n";
        } else {
            timey->stop();
            animate = !animate;
            std::cout << "Animation closed\n";
        }
    } else if (e->key() == Qt::Key_R){
        grid->resetT();
    } else {
        return;
    }
    // Redraw OpenGL.

    update();
}


void OpenGLDisplayWidget::updateMVPMatrix()
{
    // Calculate a simple model view transformation from rotation angles
    // and distance to camera.
    // NOTE: Read from bottom to top.

    QMatrix4x4 mvMatrix;
    mvMatrix.translate(0.0, 0.0, distanceToCamera);
    mvMatrix.rotate(rotationAngles.y(), QVector3D(1.0, 0.0, 0.0));
    mvMatrix.rotate(rotationAngles.x(), QVector3D(0.0, 1.0, 0.0));
    mvMatrix.translate(-1.0, -1.0, -1.0);
    mvMatrix.scale(2.0);

    mvpMatrix = projectionMatrix * mvMatrix;
}

void OpenGLDisplayWidget::animateVisual() {
    grid->updateT();
    update();
}


void OpenGLDisplayWidget::initVisualizationPipeline()
{
    // Initialize the visualization pipeline:

    // Initialize data source(s).
    grid = new FlowDataSource();
    grid->createData(XValue,YValue,ZValue, 0);

    // Initialize filter modules.
    filter = new CartesianGridToHorizontalSliceFilter();
    filter->setDataSource(grid->returnSource());
    filter->setSlice(0);
    filter->setWindComponent(0); // The x-component

    // Initialize mapper modules.
    mapper = new HorizontalSliceToImageMapper();
    mapper->getSlice(filter->passSlice(XValue,YValue), XValue,YValue);


    contourmapper = new HorizontalSliceToContourLineMapper(); //Mapper caused the program to crash, but not anymore
    contourmapper->getSlice(filter->passSlice(XValue,YValue), XValue,YValue,ZValue, 0);
    float *isos = new float[3];
    isos[0] = 0.1;
    isos[1] = 0;
    isos[2] = -0.1;
    contourmapper->setIso(isos, 3);
    delete[] isos;
    streamlinemapper = new StreamlineMapper();
    streamlinemapper->getData(filter->passCube(), XValue, YValue, ZValue);
    streamlinemapper->setValues(1000, 100);
    //streamlinemapper->setValues(125, 100);


    // Initialize rendering modules.
    //bboxRenderer = new DataVolumeBoundingBoxRenderer();
    renderer = new HorizontalSliceRenderer(0, ZValue);
    contourrenderer = new HorizontalContourLinesRenderer();
    renderer->setMapper(mapper);
    contourrenderer->setContourMapper(contourmapper);

    streamlinerenderer = new StreamlineRenderer();
    streamlinerenderer->setMapper(streamlinemapper);
}