optics / imie

#include <QtGui>
#include <QtOpenGL/QtOpenGL>
#include <GL/glu.h>

#include <math.h>

#include "qtSpectrumDisplay.h"

int axisMargins = 50;

qtSpectrumDisplay::qtSpectrumDisplay(QWidget *parent)
    : QGLWidget(parent)
{
    object = 0;
    xRot = 0;
    yRot = 0;
    zRot = 0;

    qtGreen = QColor::fromCmykF(0.40, 0.0, 1.0, 0.0);
    qtPurple = QColor::fromCmykF(0.39, 0.39, 0.0, 0.0);
}

qtSpectrumDisplay::~qtSpectrumDisplay()
{
    makeCurrent();
    glDeleteLists(object, 1);
}

QSize qtSpectrumDisplay::minimumSizeHint() const
{
    return QSize(50, 50);
}

QSize qtSpectrumDisplay::sizeHint() const
{
    return QSize(400, 400);
}

void qtSpectrumDisplay::initializeGL()
{
    //qglClearColor(qtPurple.dark());
    glClearColor(0.0, 0.0, 0.0, 0.0);
    //object = makeObject();
    glShadeModel(GL_FLAT);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
}

void qtSpectrumDisplay::printWavenumber(int xPos)
{
    int viewParams[4];
    glGetIntegerv(GL_VIEWPORT, viewParams);

    float a = (float)xPos/(float)viewParams[2];

    int wn = a * (nuMax - nuMin) + nuMin;
    cout<<wn<<endl;



}

void qtSpectrumDisplay::paintGL()
{

    //*************  Draw Absorbance/Intensity  **************************
    //get the window size
    int w = width();
    int h = height();
    glViewport(50, 30, w, h);

    //prepare the projection for spectra (orthographic, bounded by spectral values)
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(nuMin, nuMax, aMin, aMax);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    //clear the screen
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    //set the line width
    glLineWidth(1);

    //draw the simulated spectrum (in white)
    if(dispSimSpec)
    {
        glColor3f(1.0, 1.0, 1.0);
        glBegin(GL_LINE_STRIP);
        for(unsigned int i=0; i<SimSpectrum.size(); i++)
            glVertex2f(SimSpectrum[i].nu, SimSpectrum[i].A);
        glEnd();
    }
    //draw the reference spectrum in gray
    if(dispRefSpec && RefSpectrum.size() > 0)
    {
        glColor3f(0.5, 0.5, 0.5);
        glBegin(GL_LINE_STRIP);
        float nu;
        for(unsigned int i=0; i<RefSpectrum[currentSpec].size(); i++)
        {
            nu = RefSpectrum[currentSpec][i].nu;
            glVertex2f(nu, RefSpectrum[currentSpec][i].A + nu * refSlope);
        }
        glEnd();
    }

    //compute the maximum k and n
    int nSamples = MaterialList[currentMaterial].eta.size();

    //*************  Draw k  **************************
    //change the viewport properties and draw n
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(nuMin, nuMax, 0.0, kMax);
    //glMatrixMode(GL_MODELVIEW);
    //glLoadIdentity();

    float nu;
    if(dispMatK)
    {

        glColor3f(1.0, 0.0, 0.0);
        glBegin(GL_LINE_STRIP);
        for(int i=0; i<nSamples; i++)
        {
            nu = MaterialList[currentMaterial].nu[i];
            glVertex2f(nu, MaterialList[currentMaterial].eta[i].imag());
        }
        glEnd();
    }
    if(dispSimK)
    {
        glColor3f(1.0, 1.0, 0.0);
        glBegin(GL_LINE_STRIP);
        for(unsigned int i=0; i<EtaK.size(); i++)
        {
            nu = EtaK[i].nu;
            glVertex2f(nu, EtaK[i].A);
        }
        glEnd();
    }

    //*************  Draw n  **************************
    //change the viewport properties and draw n
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if(nMag < 0.1) nMag = 0.1;
    gluOrtho2D(nuMin, nuMax, baseIR - nMag, baseIR + nMag);
    if(dispMatN)
    {
        glColor3f(0.0, 1.0, 0.0);
        glBegin(GL_LINE_STRIP);
        for(int i=0; i<nSamples; i++)
        {
            nu = MaterialList[currentMaterial].nu[i];
            glVertex2f(nu, MaterialList[currentMaterial].eta[i].real());
        }
        glEnd();
    }
    if(dispSimN)
    {
        glColor3f(0.0, 1.0, 1.0);
        glBegin(GL_LINE_STRIP);
        for(unsigned int i=0; i<EtaN.size(); i++)
        {
            nu = EtaN[i].nu;
            glVertex2f(nu, EtaN[i].A);
        }
        glEnd();
    }


    glCallList(object);

    glFlush();

    //***********************  Display axes values  ****************************


    ostringstream buff;
    glViewport(0, 0, w, h);
    int nDivs = 11;
    glColor3f(1.0, 1.0, 1.0);
    for(int i = 0; i < nDivs; i++)
    {
        float divStep = (aMax - aMin)/(nDivs - 1);
        float pixStep = (float)(h - 10)/(nDivs - 1);

        buff<<aMin + i * divStep;
        renderText(0, h - i * pixStep, buff.str().c_str());
        buff.clear(); buff.str("");
    }
}

void qtSpectrumDisplay::resizeGL(int width, int height)
{


}

void qtSpectrumDisplay::mousePressEvent(QMouseEvent *event)
{
    lastPos = event->pos();

    if(event->buttons() & Qt::LeftButton)
    {
        printWavenumber(event->x());
    }
}

void qtSpectrumDisplay::mouseMoveEvent(QMouseEvent *event)
{
    lastPos = event->pos();
}

void qtSpectrumDisplay::quad(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2,
                             GLdouble x3, GLdouble y3, GLdouble x4, GLdouble y4)
{
    qglColor(qtGreen);

    glVertex3d(x1, y1, -0.05);
    glVertex3d(x2, y2, -0.05);
    glVertex3d(x3, y3, -0.05);
    glVertex3d(x4, y4, -0.05);

    glVertex3d(x4, y4, +0.05);
    glVertex3d(x3, y3, +0.05);
    glVertex3d(x2, y2, +0.05);
    glVertex3d(x1, y1, +0.05);
}

void qtSpectrumDisplay::normalizeAngle(int *angle)
{
    while (*angle < 0)
        *angle += 360 * 16;
    while (*angle > 360 * 16)
        *angle -= 360 * 16;
}