OptionPanel.cpp

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

#include "LifeVariables.h"
#include "OptionPanel.h"


using namespace std;

OptionPanel::OptionPanel(int mainWindowRef, int position) {
    this->selectedPlane = XY_PLANE;
    this->selectedSlice = 0;
    this->interpolationMode = NEAREST_SLICE;
    this->volumeInterpolationMode = NEAREST_VOLUME;
    this->viewingDirection = FRONT_VIEW;
    
    this->lightX = 1.0;
    this->lightY = 1.0;
    this->lightZ = 1.0;
   
    txFunction = 0;
    currLowerThreshold = 600;
   
    if((mainWindowRef==0)&&(position==0)) {
        panel = GLUI_Master.create_glui("Options...", 0,150,200);
    }
    else {
        panel = GLUI_Master.create_glui_subwindow(mainWindowRef, position);
        panel->set_main_gfx_window(mainWindowRef);
    }   
   
    slicingPanel = panel->add_panel("Slice Visualisation Options");
    slicingPanel->set_alignment(GLUI_ALIGN_LEFT);
     
    planeSelectorGroup = panel->add_radiogroup_to_panel(slicingPanel,
                                                       &selectedPlane,
                                                       PLANESELECT_ID,
                                                       eventListener);
                                                       
    panel->add_radiobutton_to_group(planeSelectorGroup, "XY Plane");
    panel->add_radiobutton_to_group(planeSelectorGroup, "XZ Plane");
    panel->add_radiobutton_to_group(planeSelectorGroup, "YZ Plane");
   
    panel->add_separator_to_panel(slicingPanel);
   
    sliceSpinnerPanel = 
        panel->add_panel_to_panel(slicingPanel, "", GLUI_PANEL_NONE);
   
    selectedSliceSpinner = 
        panel->add_spinner_to_panel(sliceSpinnerPanel, 
                                    "Slice",
                                    GLUI_SPINNER_INT,
                                    &selectedSlice,
                                    SLICESELECT_ID,
                                    eventListener);
   
    selectedSliceSpinner->set_int_limits(0,0,GLUI_LIMIT_WRAP);
   
    panel->add_separator_to_panel(slicingPanel);   
    interpolationSelectorGroup = panel->add_radiogroup_to_panel(slicingPanel,
                                                                &interpolationMode,
                                                                INTERPOLATIONSELECT_ID,
                                                                eventListener);
                                                       
    panel->add_radiobutton_to_group(interpolationSelectorGroup, "Nearest Neighbour");
    panel->add_radiobutton_to_group(interpolationSelectorGroup, "Bilinear");

    switchModeBtn = panel->add_button("Switch Mode", MODESELECT_ID, eventListener);
    switchModeBtn->disable();
   
    volumePanel = panel->add_panel("Volume Visualisation Options");
    volumePanel->set_alignment(GLUI_ALIGN_LEFT);
   

    txFunctionSelectorGroup = panel->add_radiogroup_to_panel(volumePanel,
                                                             &txFunction,
                                                             TXFUNCTIONSELECT_ID,
                                                             eventListener);

    panel->add_radiobutton_to_group(txFunctionSelectorGroup, "First HIT");
    panel->add_radiobutton_to_group(txFunctionSelectorGroup, "X-Ray");
    panel->add_radiobutton_to_group(txFunctionSelectorGroup, "MIP");
    //panel->add_radiobutton_to_group(txFunctionSelectorGroup, "Compositing");

    thresholdSpinnerPanel = 
        panel->add_panel_to_panel(volumePanel, "First Hit Threshold", GLUI_PANEL_NONE);
        
    lowerThresholdSpinner = 
        panel->add_spinner_to_panel(thresholdSpinnerPanel, 
                                 "Threshold",
                                 GLUI_SPINNER_INT,
                                 &currLowerThreshold,
                                 SLICESELECT_ID,
                                 eventListener);

    volumeInterpolationSelectorGroup = panel->add_radiogroup_to_panel(volumePanel,
                                                                    &volumeInterpolationMode,
                                                                    VOLUMEINTERPOLATIONSELECT_ID,
                                                                    eventListener);

    panel->add_radiobutton_to_group(volumeInterpolationSelectorGroup, "Nearest Neighbour");
    panel->add_radiobutton_to_group(volumeInterpolationSelectorGroup, "Triliniear Interpolation");

    
    viewpointPanel = panel->add_panel_to_panel(volumePanel,"View...");
    viewpointGroup = panel->add_radiogroup_to_panel(viewpointPanel, 
                                                    &viewingDirection,
                                                    VIEWINGDIRECTION_ID,
                                                    eventListener);

   // panel->add_radiobutton_to_group(viewpointGroup, "Front");
    panel->add_radiobutton_to_group(viewpointGroup, "Front");
    panel->add_radiobutton_to_group(viewpointGroup, "Side");
    panel->add_radiobutton_to_group(viewpointGroup, "Top");
    panel->add_radiobutton_to_group(viewpointGroup, "A Pose");
   
    
    lightPositionPanel = panel->add_panel_to_panel(volumePanel, "Light Direction");
    lightXPosition = panel->add_edittext_to_panel(lightPositionPanel, "x",
                                                  GLUI_EDITTEXT_FLOAT,
                                                  &lightX);
    lightYPosition = panel->add_edittext_to_panel(lightPositionPanel, "y",
                                                  GLUI_EDITTEXT_FLOAT,
                                                  &lightY);
    lightZPosition = panel->add_edittext_to_panel(lightPositionPanel, "z",
                                                  GLUI_EDITTEXT_FLOAT,
                                                  &lightZ);

    lightXPosition->set_float_limits(-1.0, 1.0, GLUI_LIMIT_CLAMP);
    lightYPosition->set_float_limits(-1.0, 1.0, GLUI_LIMIT_CLAMP);
    lightZPosition->set_float_limits(-1.0, 1.0, GLUI_LIMIT_CLAMP);


    refreshBtn = panel->add_button_to_panel(volumePanel, "Refresh", REFRESH_ID, eventListener);

    panel->disable();
}


void OptionPanel::enable() {
    panel->enable();
}   


void OptionPanel::disable() {
    panel->disable();
}

void OptionPanel::enableModeSelection() {
    renderMode = SLICE_VISUALISATION;
    switchModeBtn->enable();
}

void OptionPanel::disableModeSelection() {
    renderMode = -1;
    switchModeBtn->disable();
}


void OptionPanel::switchRenderMode(int mode) {
    if(mode == SLICE_VISUALISATION) {
        volumePanel->disable();
        slicingPanel->enable();
    }
    else if(mode == VOLUME_VISUALISATION) {
        slicingPanel->disable();
        volumePanel->enable();        
    }
    else {
        slicingPanel->disable();
        volumePanel->disable();
    }
}


void OptionPanel::updateSliceMax(int valX, int valY, int valZ) {
    switch(optionPanel->selectedPlane) {
        case 0: 
            selectedSliceSpinner->set_int_limits(0, valZ, GLUI_LIMIT_WRAP);    
            break;
        case 1: 
            selectedSliceSpinner->set_int_limits(0, valX, GLUI_LIMIT_WRAP);    
            break;
        case 2:
            selectedSliceSpinner->set_int_limits(0, valY, GLUI_LIMIT_WRAP);
            break;
    }
    selectedSliceSpinner->set_int_val(0);
}


void OptionPanel::incSlice() {
    selectedSlice = selectedSlice + 1;
    selectedSliceSpinner->set_int_val(selectedSlice);
}


void OptionPanel::decSlice() {
    selectedSlice = selectedSlice - 1;
    selectedSliceSpinner->set_int_val(selectedSlice);
}

void OptionPanel::disableMipSpinners() {
    thresholdSpinnerPanel->disable();  
}

void OptionPanel::enableMipSpinners() {
    thresholdSpinnerPanel->enable();  
}

---