Histogram.cpp

#include <iostream>
#include <string>
#include <glut.h>
#include <glui.h>
#include <glu.h>
#include <math.h>

#include "LifeVariables.h"
#include "Histogram.h"
#include "TxFunction.h"

using namespace std;

Histogram::Histogram(): GuiComponent(0, HISTOGRAM_VALUE_RANGE,0,1,0,0,1,1) {
    this->txFunction = NULL;
    this->initialised = false;
    this->grabbedPoint = NULL;
    this->state = ENABLED;    
}


void Histogram::update(unsigned short *data, unsigned int &size) {
    this->hide();
    if(this->txFunction != NULL) {
        delete this->txFunction;
    }
    
    // loop counter
    int i = 0;
    int maxValue = 0;

    // initialise the array with zeros
    for(i=1; i < HISTOGRAM_VALUE_RANGE; i++) {
        occurrenceArray[i] = 1;
    }

    // count the densities and store the occurrence
    for(i=1; i<size; i++) {
        occurrenceArray[data[i]]+=1;
        
        if(maxValue < data[i]) {
            maxValue = data[i];
        }
    }
    this->initialised = true;

    // update the top plane
    this->top = maxValue;
    this->oneAlphaPercent = 1.0f/this->top;
    this->txFunction = new TxFunction(0,0,HISTOGRAM_VALUE_RANGE_FLOAT,this->top);
    
    cout << top << " " << oneAlphaPercent << endl;

    this->enable();
}


void Histogram::onLeftMouseClick(int x, int y) {
    if((this->state == ENABLED)&&(this->hit(x,y))) {
        // calculate the mouse position in the world coordinates of the histogram   
        this->getLocalWorldCoordinates(x, y);
        // check if the point is already in, if not add it
        grabbedPoint = txFunction->hitTxPoint(x,y);
        if (grabbedPoint == NULL) {          
            txFunction->addControlPoint(x,y,1,1,1,(float)y*(float)this->oneAlphaPercent);
            grabbedPoint = txFunction->hitTxPoint(x,y);
        }
    }
}


bool Histogram::onRightMouseClick(int x, int y) {
    if((this->state == ENABLED)&&(this->hit(x,y))) {
        // calculate the mouse position in the world coordinates of the histogram   
        this->getLocalWorldCoordinates(x, y);

        // check wether the point is already in, if so, move it
        // otherwise add it
        grabbedPoint = txFunction->hitTxPoint(x,y);
        if(grabbedPoint != NULL) {
            // change the render state to selected
            this->disable();
            return true;
        }
        else { 
            return false;
        }
    }
    else {
        return false;
    }
}


void Histogram::onMouseDrag(int x, int y) {
    if((this->state == ENABLED)&&(this->hit(x,y))) {
        // calculate the mouse position in the world coordinates of the histogram   
        this->getLocalWorldCoordinates(x, y);

        if(grabbedPoint!= NULL) {            
            //cout << "equals " << grabbedPoint->equals(txFunction->getLastTxPoint()) << endl;
            // start moving
            txFunction->moveControlPoint(grabbedPoint, x, y);
            grabbedPoint->rgba[3] = (float)y*(float)this->oneAlphaPercent;
        }
    }
}


void Histogram::render(int x, int y, int width, int height) {    
    if(this->state != HIDDEN) {
        int i = 0;        
        // store the current drawing color on the attribute stack
        glPushAttrib(GL_CURRENT_BIT);
        
        // setup orthographic projection at a specific point x,y 
        this->startCamera(x,y,width,height);
        
        // if the data had not been initalised, do not draw
        if(this->initialised == true) {
            
            // render the shape of the transfer function
            txFunction->render();
            
            i = 0;            
            glColor3f(0.2,0.2,0.2);            
            
            // draw the grid and the description
            int j = 0;
            
            while(i < HISTOGRAM_VALUE_RANGE) {
                glBegin(GL_LINES);
                    glVertex2i(i, 0);
                    glVertex2i(i, this->top);                    
                glEnd();               
                i+=HISTOGRAM_VGRID_SIZE;                
                glPushAttrib(GL_CURRENT_BIT);
                    glColor3f(0.4,0.5,0.4);                 
                    renderString(i,this->top/*-200*/,FONT,i);
                glPopAttrib();
            }            
            
            // draw the vertical lines - the data
            glColor3f(0.9, 0.9 , 0.8);       
            for(i=0; i< HISTOGRAM_VALUE_RANGE; i++) {
                glBegin(GL_LINES);
                    glVertex2i( i, 0);
                    glVertex2i( i, occurrenceArray[i]-1);
                glEnd();                
            }
            
            // the background quad of the histogram
            glColor3f(0.4,0.5,0.4);        
            glBegin(GL_QUADS);
                glVertex2i(0, 0);
                glVertex2i(HISTOGRAM_VALUE_RANGE, 0);
                glVertex2i(HISTOGRAM_VALUE_RANGE, this->top);
                glVertex2i(0, this->top);
            glEnd();
            
        }

        // reset the old projection
        this->stopCamera();

        // restore the drawing color
        glPopAttrib();
    }
}


void Histogram::getColorByDensity(unsigned short &density, 
                                  float &red, float &green, float &blue, float &alpha) {
    // here might be a switch for different interpolation modes

    this->txFunction->getLinearInterpolatedColor(density, red, green, blue, alpha);
}


void Histogram::getVoxelColorByDensity(float density, 
                                       float &red, float &green, float &blue) {
    this->txFunction->getLinearInterpolatedVoxelColor(density, red, green, blue);
}


void Histogram::getLevoyVoxelColor(float density, 
                                   float &red, float &green, float &blue, float gradient) {
    this->txFunction->getLevoyVoxelColor(density, red, green, blue, gradient);
}

void Histogram::getSolidVoxelColorByDensity(float density, 
                                       float &red, float &green, float &blue) {
    this->txFunction->getSolidVoxelColor(density, red, green, blue);
}



bool Histogram::removeControlPoint() {
    if(this->grabbedPoint == NULL) {        
        return false;
    }
    else {        
        this->txFunction->removeControlPoint(grabbedPoint);
        return true;
    }
}

---