langmuirviewer.h

Go to the documentation of this file.

#ifndef LANGMUIRVIEWER_H
#define LANGMUIRVIEWER_H

#include <QGLViewer/qglviewer.h>
#include <QGLViewer/manipulatedCameraFrame.h>
#include <QErrorMessage>
#include <QColorDialog>
#include <QMatrix4x4>
#include <QSettings>

#include "isosurface.h"
#include "corneraxis.h"
#include "pointcloud.h"
#include "light.h"
#include "grid.h"
#include "rand.h"
#include "mesh.h"
#include "box.h"

#define BOOST_DISABLE_ASSERTS

#ifndef Q_MOC_RUN

#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
#pragma GCC diagnostic push
#pragma GCC system_header
#endif

#include "boost/multi_array.hpp"

#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
#pragma GCC diagnostic pop
#endif

#endif

namespace LangmuirCore {
    class Simulation;
    class World;
}

namespace LangmuirView {

class LangmuirViewer : public QGLViewer
{
    Q_OBJECT
public:
    explicit LangmuirViewer(QWidget *parent = 0);

    ~LangmuirViewer();

    QMatrix4x4& getModelViewProjectionMatrix();

    QMatrix4x4& getProjectionMatrix();

    QMatrix4x4& getOpenGLModelViewMatrix();

    QMatrix4x4& getOpenGLProjectionMatrix();

    LangmuirCore::Random& random();

    bool okToCalculateIsoSurface() { return m_canCalculateIsoSurface; }

    const QColor& trapColor() const { return m_trapColor; }

    const QColor& stageColor2() const { return m_stageColor2; }

    CornerAxis & cornerAxis() { return *m_cornerAxis; }

    PointCloud & electrons() { return *m_electrons; }

    PointCloud & defects() { return *m_defects; }

    PointCloud & holes() { return *m_holes; }

    PointCloud & traps() { return *m_traps; }

    Box & rightBox() { return *m_rBox; }

    Box & leftBox() { return *m_lBox; }

    Box & baseBox() { return *m_baseBox; }

    Box & trapBox() { return *m_trapBox; }

    Box & stageBox() { return *m_stageBox; }

    Mesh & trapMesh() { return *m_trapMesh; }

    Light & light() { return *m_light0; }

    Grid & grid() { return *m_grid; }

signals:
    void showMessage(const QString& message, int timeout=0);

    void clearMessage();

    void isUsingOpenCL(bool useOpenCL);

    void isUsingCoulomb(bool useCoulomb);

    void isAnimated(bool playing);

    void isShowingTraps(bool shown);

    void iterationsPrintChanged(int value);

    void currentStepChanged(int value);

    void openGLInitFinished();

    void trapColorChanged(QColor color);

    void stageColor2Changed(QColor color);

    void backgroundColorChanged(QColor color);

    void canCalculateIsoSurface(bool able);

    void isoSurfaceProgress(int);

    void checkerSizeChanged(float);

public slots:
    void setElectronPointMode(PointCloud::Mode mode);

    void setDefectPointMode(PointCloud::Mode mode);

    void setHolePointMode(PointCloud::Mode mode);

    void setPointMode(PointCloud::Mode mode);

    void setIterationsPrint(int value);

    void toggleTrapsShown(bool on=true);

    void toggleOpenCL(bool on=true);

    void toggleCoulomb(bool on=true);

    void toggleCornerAxisIsVisible();

    void toggleGridIsVisible();

    void load(QString fileName);

    void save(QString fileName);

    void resetCamera();

    void unload();

    void reset();

    void pause();

    void play();

    void showParameters();

    void drawLightSource(GLenum light, float scale = 1.0f) const;

    void loadSettings(QString fileName);

    void saveSettings(QString fileName);

    void errorMessage(QString message);

    void setSettings(QSettings &settings);

    void getSettings(QSettings &settings);

    void setTrapColor(QColor color);

    void setStageColor2(QColor color);

    void setBackgroundColor(QColor color);

    void initTraps();

    void initStage();

    void generateIsoSurface(float value);

    void updateTrapMesh();

    void resetSettings();

    void setCanCalculateIsoSurface(bool enabled);

    void setCheckerSize(float size);

protected:
    void updateElectronCloud();

    void updateDefectCloud();

    void updateTrapCloud();

    void updateHoleCloud();

    void initGeometry();

    virtual void init();

    virtual void preDraw();

    virtual void draw();

    virtual void postDraw();

    virtual void animate();

    virtual void help();

    virtual QString helpString() const;

    void drawTraps(QImage &image, QColor bcolor, QColor fcolor);

    void drawChecker(QImage &image, QColor color1, QColor color2);

    void loadTexture(GLuint imageID, QImage &image);

    GLuint m_textures[2];

    CornerAxis *m_cornerAxis;

    PointCloud *m_electrons;

    PointCloud *m_defects;

    PointCloud *m_holes;

    PointCloud *m_traps;

    Box *m_trapBox;

    Box *m_baseBox;

    Box *m_lBox;

    Box *m_rBox;

    Box *m_stageBox;

    double m_boxThickness;

    QColor m_trapColor;

    QColor m_stageColor2;

    Grid *m_grid;

    Mesh *m_trapMesh;

    MarchingCubes::Isosurface *m_isoSurface;

    Light *m_light0;

    LangmuirCore::Simulation *m_simulation;

    LangmuirCore::Random m_random;

    LangmuirCore::World *m_world;

    float m_gridHalfX;

    float m_gridHalfY;

    float m_gridHalfZ;

    float m_gridX;

    float m_gridY;

    float m_gridZ;

    QErrorMessage *m_error;

    bool m_canCalculateIsoSurface;

    float m_sceneRadius;

    float m_stageExtend;

    float m_checkerSize;
};

}

#endif // LANGMUIRVIEWER_H