TxFunction.cpp

#include <gl/glut.h>
#include <algorithm>
#include <vector>
#include <cmath>
#include <iostream>
#include <iostream>


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

using namespace std;


TxFunction::TxFunction(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) {    
    this->addControlPoint(x1, y1, 0, 0, 0, 1);
    this->addControlPoint(x2, y2, 1, 1, 1, 0);
}


TxPoint* TxFunction::hitTxPoint(float x, float y) {
    vector<TxPoint>::iterator it = this->controlPoints.begin();
    for(;it < this->controlPoints.end(); it++) {
        if(it->hit(x,y) == true) {
            return it;
        }
    }
    return NULL;
}


TxPoint* TxFunction::getLastTxPoint() {
    return this->controlPoints.end();    
}


TxPoint* TxFunction::getFirstTxPoint() {
    return this->controlPoints.begin();    
}


void TxFunction::moveControlPoint(TxPoint *point, GLfloat x, GLfloat y) {    
    //
    // QQ add restriction to avoid moving the endpoint
    //
    point->moveTo(x,y);
    sort(this->controlPoints.begin(),this->controlPoints.end());    
}


void TxFunction::addControlPoint(float x, float y, 
                                 float red, float green, float blue, float alpha) 
{
    TxPoint cP(x, y, red, green, blue, alpha);
    this->controlPoints.push_back(cP);
    // cout << "x: " << x <<" y:"<< y <<" alpha:"<< alpha << " listsize:"<< controlPoints.size()<<endl;
    // sort the points from the beginning to the end
    sort(this->controlPoints.begin(),this->controlPoints.end());        
}


void TxFunction::removeControlPoint(TxPoint *p) {
    vector<TxPoint>::iterator it = this->controlPoints.begin()+1;
    for(;it < this->controlPoints.end()-1; it++) {
        if(it == p) {
            this->controlPoints.erase(it,it+1);            
            return;            
        }
    }
}


void TxFunction::render() {
    vector<TxPoint>::iterator it = this->controlPoints.begin();
    for(;it < this->controlPoints.end(); it++) {
        it->render();
        if(it< this->controlPoints.end()-1) {
            glPushAttrib(GL_CURRENT_BIT);
            glColor4fv(it->rgba);
            glBegin(GL_LINES);
                glVertex2fv(it->position);
                glVertex2fv((it+1)->position);
            glEnd();
            glPopAttrib();
        }
    }    
}


TxPoint* TxFunction::getNearestNeighbour(unsigned short density) {
    vector<TxPoint>::iterator it = this->controlPoints.begin()+1;    
    do {
        if(it->position[0] > density) {            
            return it;
        }
        it+=1;
    }
    while(it < this->controlPoints.end());    
    return NULL;
}


void TxFunction::getLinearInterpolatedColor(unsigned short density, 
                                            float &red, float &green, float &blue, float &alpha) 
{

    vector<TxPoint>::iterator upper = this->getNearestNeighbour(density);
    vector<TxPoint>::iterator lower = upper-1;

    if((upper == NULL)||(lower == NULL)) { return; }

    // calculate the coefficients
    int d = upper->position[0] - lower->position[0];
    float ld = (float)(density - lower->position[0])/(float)d;
    float ud = (float)(1 - ld);
        
    float a = ud*lower->rgba[3]+ld*upper->rgba[3];
        
    red = (ud*lower->rgba[0]+ld*upper->rgba[0])*a;
    green = (ud*lower->rgba[1]+ld*upper->rgba[1])*a;
    blue = (ud*lower->rgba[2]+ld*upper->rgba[2])*a;
    

}


void TxFunction::getLinearInterpolatedVoxelColor(float density, 
                                                 float &red, 
                                                 float &green,
                                                 float &blue) 
{

    vector<TxPoint>::iterator upper = this->getNearestNeighbour(density);
    vector<TxPoint>::iterator lower = upper-1;

    if((upper == NULL)||(lower == NULL)) { return; }

    // calculate the coefficients
    int d = upper->position[0] - lower->position[0];
    float ld = (float)(density - lower->position[0])/(float)d;
    float ud = (float)(1 - ld);
    
    // alpha
    float alpha = ud*lower->rgba[3]+ld*upper->rgba[3];

    red = (ud*lower->rgba[0]+ld*upper->rgba[0])*alpha;
    green = (ud*lower->rgba[1]+ld*upper->rgba[1])*alpha;
    blue = (ud*lower->rgba[2]+ld*upper->rgba[2])*alpha;
}


void TxFunction::getSolidVoxelColor(float density, 
                                                 float &red, 
                                                 float &green,
                                                 float &blue) 
{
    vector<TxPoint>::iterator upper = this->getNearestNeighbour(density);    

    if(upper == NULL) { return; }
    
    red = upper->rgba[0];
    green = upper->rgba[1];
    blue = upper->rgba[2];
}


// thickness of surface
int r = 50;
// selected density
int f_v = 1000;

float a_v = 1.0f;

void TxFunction::getLevoyVoxelColor(float f_xi,
                                    float &red, float &green, float &blue, float gradient) {
    
    red = 1;
    green = 1;
    blue = 1;

    float lower = f_xi - r*gradient;
    float upper = f_xi + r*gradient;
    

    if((gradient == 0)&&(f_xi = f_v)) {
        return;    
    }
    else if((gradient > 0)&&(lower < f_v)&&(upper > f_v)){
        a_v = 1.0f -1.0f/r*(abs(f_v-f_xi/gradient));
        red = red*a_v;
        green = green*a_v;
        blue = blue*a_v;
    }
    else {
        red = 0.2;
        green = 0.2;
        blue = 0.2;
    }
}

---