main.cpp

#include <iostream>
#include <glui.h>
#include <glut.h>
#include <sstream>

#include "LifeVariables.h"

using namespace std;


/*
 * Section: Init
 *
 *    This section initalise all globals that are defined as extern in 
 *    LifeVariables.h
 *
 */

int xResolution = X_RES;

int yResolution = Y_RES;

int mainWindow = 0;

RawReader *reader = NULL;;

MenuBar *menuBar = NULL;;

StateBar *stateBar = NULL;;

FileDialog *fileDialog = NULL;; 

OptionPanel *optionPanel = NULL;

Histogram *histogram = NULL;

ViewPort *mainViewPort = NULL;

int mouseBtn = -1;

ColorCubePanel *colorSelector = NULL;

ProgramState currentProgramState = START;

bool debugMode = DEBUG_MODE;

CVolVoxels GVolVoxels;

CDensities GDensities;

CTex GTex;

CScanner    GScanner;



bool refresh = true;

/*
 * Section: Implementation
 *
 *    This gives an implementation to the extern functions 
 *    defined in LifeVariables.h
 *
 *
 */


void showGlDebugMessages() {    
    switch (glGetError()) {
        case GL_NO_ERROR: break;
        case GL_INVALID_ENUM: 
            cout << "GL_INVALID_ENUM: An unacceptable value is specified for an enumerated argument." << endl;
            break;
        case GL_INVALID_VALUE: 
            cout << "GL_INVALID_VALUE: A numeric argument is out of range." << endl;
            break;
        case GL_INVALID_OPERATION:
            cout << "GL_STACK_OVERFLOW: The specified operation is not allowed in the current state." << endl;
            break;
        case GL_STACK_OVERFLOW: 
            cout << "GL_STACK_OVERFLOW: This function would cause a stack overflow." << endl;
            break;
        case GL_STACK_UNDERFLOW:
            cout << "GL_STACK_UNDERFLOW: This function would cause a stack underflow." << endl;
            break;
        case GL_OUT_OF_MEMORY: 
            cout << "GL_OUT_OF_MEMORY: There is not enough memory left to execute the function." << endl;
            break;
        default: break;
    }     
}


void renderString(int x, int y, void *font, int nr) {
    string text="";
    ostringstream outStream;
    outStream << nr;
    text = outStream.str();
    renderString(x,y,font,text);
}


void renderString(int x, int y, void *font, string text) {
    glRasterPos2i(x, y);    
    for(int i = 0; i < text.length(); i++) {
       glutBitmapCharacter(font, text[i]);       
    }    
}

extern void RenderVolume();


void display() {
  
    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity();

    // setup the background color
    glClearColor(0.0,0.0,0.0,0.0);

    // clear everything drawn so far
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    glViewport(mainViewPort->x, 
               mainViewPort->y+HISTOGRAM_WND_HEIGHT/2,
               mainViewPort->w, 
               mainViewPort->h);
    
    // render crap with respect to the program state:    
    switch(currentProgramState) {
        // if in VOLUME_MODE, render the volume
        case VOLUME_MODE:
            
            // QQ:  RenderVolume should go here.... 
            //
            //
            colorSelector->render();

            histogram->render(mainViewPort->x, 
                              mainViewPort->y,
                              mainViewPort->w,
                              HISTOGRAM_WND_HEIGHT);

            GScanner.ScanVolume();

            GTex.RenderVolumeSubTexture();
                // refresh false will make the texture disappear after rendering due to
                // the swap buffers call at the end..
                // swap buffers can not be removed -> there must be a second way
                // of showing the texture without raycasting
                //refresh = false;                
            
            break;

        // if in SLICE_MODE, render the slices
        case SLICE_MODE:           
            colorSelector->render();

            histogram->render(mainViewPort->x, 
                              mainViewPort->y,
                              mainViewPort->w,
                              HISTOGRAM_WND_HEIGHT);

            
            // process the image if possible            
            if(GVolVoxels.GetDimX()) {
                GTex.RenderSubTexture();
            }            
            break;

        // if UNLOADING do not render anything, the pointers
        // to the dataset are not valid
        case UNLOADING:            
            break;

        // if LOADING do not render anything, the pointers
        // to the dataset are not valid yet
        case LOADING:
            break;
        
        // by default we are in state START, do not render:
        default:            
            break;

    }      
    // if the program is in debug mode, show verbose messages
    if(debugMode) {
        showGlDebugMessages();
    }
    // swap the buffers
    glutSwapBuffers(); 
}



void reshape(int x, int y) {
    GLUI_Master.get_viewport_area(&mainViewPort->x, 
                                  &mainViewPort->y,
                                  &mainViewPort->w,
                                  &mainViewPort->h);

    glViewport(mainViewPort->x, 
               mainViewPort->y+HISTOGRAM_WND_HEIGHT/2,
               mainViewPort->w, 
               mainViewPort->h);

    glMatrixMode(GL_PROJECTION);    
    glLoadIdentity();

    if (mainViewPort->w <= mainViewPort->h) {
        glOrtho(-2.0, 
                 2.0,
                -2.0 * (GLfloat) mainViewPort->h / (GLfloat) mainViewPort->w, 
                 2.0 * (GLfloat) mainViewPort->h / (GLfloat) mainViewPort->w,  
                -3.0, 
                 3.0);
    }
    else {
        glOrtho(-2.0 * (GLfloat) mainViewPort->w / (GLfloat) mainViewPort->h, 
                 2.0 * (GLfloat) mainViewPort->w / (GLfloat) mainViewPort->h,
                -2.0,
                 2.0,
                -3.0,
                 3.0);
    }
    
    colorSelector->refreshDragBounds(x, y);
    xResolution = x;
    yResolution = y;
    glutPostRedisplay();
    glMatrixMode(GL_MODELVIEW); 
    
}


void idle() {
  Sleep(10);
  glutSetWindow(mainWindow);
  GLUI_Master.sync_live_all();
}


void enterUnloadedMode() throw(Error) {   
    if(currentProgramState == SLICE_MODE) {       
        // prevent the rendering - set the state at first
        currentProgramState = UNLOADING;
        if(debugMode == true) cout << "currentProgramState = UNLOADING" << endl;
    
        // disable the mode selection and the option panel
        optionPanel->disable();                
               

        // clean up the slice pointers
        GTex.Shutdown();        
        GDensities.Shutdown();
        GVolVoxels.Shutdown();

        currentProgramState = UNLOADED;
        if(debugMode == true) cout << "currentProgramState = UNLOADED" << endl;
        return;
    }   

    else if(currentProgramState == VOLUME_MODE) {
        // prevent the rendering - set the state at first
        currentProgramState = UNLOADING;
        stateBar->updateRenderInfo("Unloading file");
        if(debugMode == true) cout << "currentProgramState = UNLOADING" << endl;
        
        // disable the mode selection and the option panel
        optionPanel->disable();

        //
        // QQ unload volume data
        //

        currentProgramState = UNLOADED;
        if(debugMode == true) cout << "currentProgramState = UNLOADED" << endl;
        stateBar->updateRenderInfo("Unloading complete");        
    }
    
    else if (currentProgramState == START ) {        
        return;
    }

    else {        
        throw Error("Can not unload data."); 
    }
}


void enterLoadedMode() throw (Error) {
    if((currentProgramState == START) || (currentProgramState == UNLOADED)) {
        currentProgramState = LOADING;
        stateBar->updateFileInfo("-");
        stateBar->updateRenderInfo("Loading File...");
        if(debugMode == true) cout << "currentProgramState = LOADING" << endl;

        // open the new file - throws the error if the file is
        reader->open(menuBar->selectedFile);
        currentProgramState = LOADED;
        if(debugMode == true) cout << "currentProgramState = LOADED" << endl;
        stateBar->updateRenderInfo("Loading complete");
        return;
    }
    else {
        throw Error("Can not load data.");
    }
}


void enterSlicingMode() throw (Error) { 
    
    if(currentProgramState == LOADED) {
        stateBar->updateRenderInfo("Preparing Data...");
        // init the texture thing
        GVolVoxels.Init(reader->voxelData, 
                       reader->dimX,
                       reader->dimY,
                       reader->dimZ);

        histogram->update(reader->voxelData, reader->size);

        // refresh the gui:
        // enable the mode selection
        optionPanel->enableModeSelection();

        // enable the option panel (will set the default visualisation mode)
        optionPanel->switchRenderMode(SLICE_VISUALISATION);

        // set the slice spinner to 0
        optionPanel->updateSliceMax(reader->dimX, reader->dimY, reader->dimZ);

        // update the statebar with information of other gui components
        stateBar->updateFileInfo(reader->fileInfoString);
        stateBar->updateRenderInfo("Slice Visualisation");
       
        currentProgramState = SLICE_MODE;
        if(debugMode == true) cout << "currentProgramState = SLICE_MODE" << endl;
    }

    else if(currentProgramState == VOLUME_MODE) {
        // destroy VOLUME_MODE mode to stop rendering
        currentProgramState = SWITCHING;
        if(debugMode == true) cout << "currentProgramState = SWITCHING" << endl;

        //
        // QQ unload the volume
        //

        // init the texture thing - some error :
        // might happen because reader->voxelData had been deleted
        // during the last shutdown ???
        // currently works when press open again
        /*
        GVolVoxels.Init(reader->voxelData, 
                        reader->dimX,
                        reader->dimY,
                        reader->dimZ);
        */
        optionPanel->switchRenderMode(SLICE_VISUALISATION);
        stateBar->updateRenderInfo("Slice Visualisation");
        
        currentProgramState = SLICE_MODE;
        if(debugMode == true) cout << "currentProgramState = SLICE_MODE" << endl;
    }
    else {
        throw Error("Can not enter Slice Mode.");
    }
}


void enterVolumeMode() throw (Error){
    if(currentProgramState == SLICE_MODE) {
        // destroy SLICE_MODE to stop rendering
        currentProgramState = SWITCHING;
        if(debugMode == true) cout << "currentProgramState = SWITCHING" << endl;

        optionPanel->switchRenderMode(VOLUME_VISUALISATION);
        stateBar->updateRenderInfo("Volume Visualisation");

        //QQ need to create a new texture, then shutdown this texture.
        // shutdown the slice mode pointer
        // GVolVoxels.Shutdown();
        // GDensities.Shutdown();
        // GTex.Shutdown();

        //
        // QQ init the volumevisualisation
        //
        // Need to get eye opsition and ray direction here, pass it to init.
        //
        //GScanner.direction = optionPanel->viewingDirection;
        //GScanner.Init();
        
        currentProgramState = VOLUME_MODE;
        if(debugMode == true) cout << "currentProgramState = VOLUME_MODE" << endl;
        eventListener(REFRESH_ID);
    }
    else {
        throw Error("Can not enter Volume Mode.");
    }    
}



void eventListener(int control) {
    
    ProgramState oldState = currentProgramState;
    
    switch(control) {

        // if the user push the refresh button
        case REFRESH_ID:
            //
            // QQ add here code that says: do new raycasting
            //  this code should use all parameters/globals
            //  and create a new image by this way
            //
            refresh = true;            
            GScanner.direction = optionPanel->viewingDirection;           
            GScanner.Init();
            cout << "REFRESH_ID" << endl;
            break;

        // if the user push the button beside the drop down list
        case OPEN_FILE_ID:            
            try {
                enterUnloadedMode();
                enterLoadedMode();    
                enterSlicingMode();
            }
            catch (Error e){
                cout << e.getErrorMsg() << endl;
                currentProgramState = oldState;                
            }          
            break;

        // the the user switch the visualisation mode
        case MODESELECT_ID:            
            if(currentProgramState == SLICE_MODE) {
                 enterVolumeMode();
            }
            else {            
                 enterSlicingMode();
            }             
            break;

        // if the user switch the plane (slicing mode)
        case PLANESELECT_ID:
             optionPanel->updateSliceMax(reader->dimX, reader->dimY, reader->dimZ);
             break;

        // if the user switch the transferfunction
        case TXFUNCTIONSELECT_ID:            
            if(optionPanel->txFunction == XRAY) {
                optionPanel->disableMipSpinners();
            }
            else if(optionPanel->txFunction == COMPOSITING) {                
                optionPanel->disableMipSpinners();                
            }
            else if (optionPanel->txFunction == FIRST_HIT) {
                optionPanel->enableMipSpinners();
            }
            else if (optionPanel->txFunction == MIP) {                             
                optionPanel->disableMipSpinners();
            }
            break;

        // if the user change the selected slice
        //case SLICESELECT_ID:             
        //     break;
        case VIEWINGDIRECTION_ID:
            GScanner.direction = optionPanel->viewingDirection;
            cout << GScanner.direction << endl;
            break;

        // if the user wants to change the search path
        case SHOWOPENFILEDLG_ID:
             fileDialog->show();
             break;

        // if the user confirms the search path dialog
        case CONFIRMOPENFILEDLG_ID:
             fileDialog->confirm();
             try {                 
                 reader->openPath(fileDialog->path);
                 menuBar->updateFileList();
                 optionPanel->disable();                 
             }
             catch (Error e) {
                 fileDialog->show(e.getError());
             }
             break;

        // if the user cancel the search path dialog
        case CANCELOPENFILEDLG_ID:
             fileDialog->hide();
             break;

        // default just do nothing
        default: break;
    }
    glutSetWindow(mainWindow);
    GLUI_Master.sync_live_all();
  
    // call display will refresh immediatly and
    // switch to the idle function afterwards
    display();
}



void deInit() {
    delete fileDialog;
    delete optionPanel;
    delete stateBar;
    delete menuBar;
    delete reader;   
    delete histogram;
    delete mainViewPort;
}


void keyEvent(unsigned char key, int x, int y) {
        switch(key) {
            case 27:
            //deInit();
            exit(0);
        case 127:
            histogram->updating();
            histogram->removeControlPoint();
            histogram->enable();
            display();
            break;
        default: 
            cout << "Key '"<< key <<"' is not assigned! (Press Esc to quit)" << endl;
            break;
        }
    display();
}


void mouseEvent(int button, int state, int x, int y) {
  
    // flip y
    y = yResolution - y;
    
    if((button == GLUT_LEFT_BUTTON)&&(state == GLUT_DOWN)) {
        mouseBtn = GLUT_LEFT_BUTTON;
        histogram->onLeftMouseClick(x,y);
        // if the user pressed left button, the color gets
        // selected and the histogram gets enabled again
        if(colorSelector->onMouseDown(x,y)) {
            histogram->enable();
        }
        display();
    }

    else if((button == GLUT_RIGHT_BUTTON)&&(state == GLUT_DOWN)) {
        mouseBtn = GLUT_RIGHT_BUTTON;
        // if some point had been selected, the histogram
        // gets disabled and returns true
        if(histogram->onRightMouseClick(x,y)) {
            // flip y
            colorSelector->moveTo(x,y);
            // thus we enable the color selection cube
            colorSelector->enable();
            colorSelector->point = histogram->grabbedPoint;
        }
    }
    else if((button == GLUT_WHEEL_UP)&&(state != GLUT_DOWN)) {
        mouseBtn = GLUT_WHEEL_UP;
        if(currentProgramState == SLICE_MODE) {
            optionPanel->incSlice();  
        }

    }

    else if((button == GLUT_WHEEL_DOWN)&&(state != GLUT_DOWN)) {
        mouseBtn = GLUT_WHEEL_DOWN;
        if(currentProgramState == SLICE_MODE) {
            optionPanel->decSlice();  
        }

    }

    if(state == GLUT_UP) {
        mouseBtn = -1;
    }
    display();
}


void mouseMotionEvent(int x, int y) {
    // note do not forget to flip the coordinate
    if(mouseBtn == GLUT_LEFT_BUTTON) {
        // flip y
        y = yResolution - y;        
        histogram->onMouseDrag(x,y);
    }
    else if(mouseBtn == GLUT_RIGHT_BUTTON) {
        colorSelector->onMouseDrag(x,y);
    }    
    display();
}


void main(int argc, char* argv[]) {
    // setting up glut stuff
    glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH );
    glutInitWindowPosition(50, 50);

    glutInitWindowSize(xResolution, yResolution);
    mainWindow = glutCreateWindow("Volume Visualiser 0.2");
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyEvent);
    glutMotionFunc(mouseMotionEvent);

    GLUI_Master.set_glutReshapeFunc(reshape);
    GLUI_Master.set_glutKeyboardFunc(keyEvent);
    GLUI_Master.set_glutMouseFunc(mouseEvent);
    GLUI_Master.set_glutIdleFunc(idle);   

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_2D);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_COLOR_MATERIAL);
    
    reader = new RawReader();        
    
    menuBar = new MenuBar(mainWindow,GLUI_SUBWINDOW_TOP);
    
    stateBar = new StateBar(mainWindow,GLUI_SUBWINDOW_BOTTOM);
    
    optionPanel = new OptionPanel(mainWindow,GLUI_SUBWINDOW_LEFT);
    
    mainViewPort = new ViewPort();

    histogram = new Histogram();

    fileDialog = new FileDialog();
    fileDialog->hide();
    
    colorSelector = new ColorCubePanel();
   
    glutMainLoop();
}

---