---

ray.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "ray.h"


Ray::Ray() {
        // richtungsvektor
        m_direction = VECTOR(1,0,0);
        // aktuelle position am strahl
        m_currentpos = VECTOR(0,0,0);
        // Koeffizient für ambient lighting
        m_ambient = 0.2f;
        // Koeffizient für diffuses lighting
        m_diffuse = 0.2f;
        // Transferfubction
        m_tf = NULL;
        // datenvolumen
        m_data = NULL;
        // Hintergrundfarbe
        m_backgroundcolor = Color(0.0,0.0,0.0);
        // aktuelle Gesamtfarbe
        m_currentcolor = Color(0.0,0.0,0.0);
        // aktueller Alphawert
        m_alpha = 0.0;
        // Startpunkt
        m_startpoint = VECTOR(0,0,0);
        // Endpunkt
        m_steplength = 1.0;
        m_specular = 0.2f;

        m_highlight = 8;

        m_light = false;
        m_viewingplane = NULL;
        mx = 0.0f;
        my = 0.0f;
        mz = 0.0f;
}

Ray::~Ray() {}

bool
Ray::SetViewingCondition(VECTOR lightpos, float ambient, float diffuse, float specular, int highlight) {
        
        if (ambient > 1.0) ambient = 1.0;
        if (ambient < 0.0) ambient = 0.0;
        if (diffuse > 1.0) diffuse = 1.0;
        if (diffuse < 0.0) diffuse = 0.0;
        if (specular > 1.0) specular = 1.0;
        if (specular < 0.0) specular = 0.0;
        if(highlight < 0) highlight = 0;
                
        m_highlight = highlight;
        m_specular = specular;
        m_ambient = ambient;
        m_diffuse = diffuse;
        return true;
}




Color
Ray::Lighting(Color color) {
        gradient_t grad = m_data->CalcGrad((int)ROUND(m_currentpos.x),(int)ROUND(m_currentpos.y),(int)ROUND(m_currentpos.z));
        VECTOR normal = VECTOR(grad.x, grad.y, grad.z);
        normal.normalize(); // normalize normal
        VECTOR len = m_currentpos - m_startpoint;
        Color ret;
        if(m_light) {
                VECTOR v = -m_direction;
                v.normalize();
                VECTOR l = m_lightpos-m_currentpos;
                l.normalize();
                VECTOR h = (v+l);
                h.normalize(); 
                ret = color*m_ambient + color*((m_diffuse*(normal.dot(m_direction))) + (m_specular*pow(normal.dot(h),m_highlight)))+ color/(4.0f+1000000.0f*len.length()); 
        }
        else ret = color*m_ambient + color*(m_diffuse*(normal.dot(m_direction))) + color/(4.0f+1000000.0f*len.length());
        return ret;
}

Color
Ray::GetCurrentColor() {
        return m_currentcolor;
}

bool
Ray::Initialize(Color background,Color current, float steplength, Plane* viewingplane, Data *data, Transfunc *tf) {
        m_backgroundcolor = background;
        m_currentcolor = current;
        m_data = data;
        m_tf = tf;
        m_steplength = steplength;
        m_viewingplane = viewingplane;
        mx = (float)m_data->GetXDim();
        my = (float)m_data->GetYDim();
        mz = (float)m_data->GetZDim();
        m_radius = sqrt(pow(mx/2.0f,2)+pow(my/2.0f,2)+pow(mz/2.0f,2));
        return true;
}

bool
Ray::SetPosDir(VECTOR currentpos, VECTOR direction) {
        m_currentpos = currentpos;
        m_direction = direction;
        return true;
}
        
bool
Ray::CastNext() {

        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
                
        bool first = true;
        int step_count = 0;
        VECTOR distancetomidpoint = VECTOR(mx/2.0f,my/2.0f,mz/2.0f)-m_currentpos;
        int steps = (int)((distancetomidpoint.length() + m_radius)/m_steplength);
        do {
                if(m_alpha > 0.99) break;
                if((m_currentpos.x >= 0.0)&&(m_currentpos.y >= 0.0)&&(m_currentpos.z >= 0.0)&&(m_currentpos.x < mx)&&(m_currentpos.y < my)&&(m_currentpos.z < mz)) {
                        if(first) {
                                m_startpoint = VECTOR(m_currentpos.x,m_currentpos.y,m_currentpos.z);
                                first = false;
                        }
                        int d = m_data->GetDensity((int)ROUND(m_currentpos.x),(int)ROUND(m_currentpos.y),(int)ROUND(m_currentpos.z));
                
                        Color help_color = m_tf->GetDensityColor(d);
                        float help_alpha = m_tf->GetOpacity(d);
                        // lightning:
                        help_color = Lighting(help_color);
                        // calculate new currentcolor:
                        m_currentcolor += help_color*(1-m_alpha)*help_alpha;
                        // calculate new alphavalue
                        m_alpha += (1-m_alpha)*help_alpha;
                }
                        // calculate new position
                m_currentpos += m_steplength*m_direction;
                
                step_count++;
        }while(step_count <= steps);
        if(m_alpha < 1.0 ) {
                m_currentcolor += m_backgroundcolor*(1.0f-m_alpha);
        }
        return true;            
}

float
Trilinear::CalcAlphaTrilinear(VECTOR pos) {

        float a000 = m_tf->GetOpacity(m_data->GetDensity(floorf(pos.x),floorf(pos.y),floorf(pos.z)));
        float a001 = m_tf->GetOpacity(m_data->GetDensity(floorf(pos.x),floorf(pos.y),ceilf(pos.z)));
        float a010 = m_tf->GetOpacity(m_data->GetDensity(floorf(pos.x),ceilf(pos.y),floorf(pos.z)));
        float a011 = m_tf->GetOpacity(m_data->GetDensity(floorf(pos.x),ceilf(pos.y),ceilf(pos.z)));
        float a100 = m_tf->GetOpacity(m_data->GetDensity(ceilf(pos.x),floorf(pos.y),floorf(pos.z)));
        float a101 = m_tf->GetOpacity(m_data->GetDensity(ceilf(pos.x),floorf(pos.y),ceilf(pos.z)));
        float a110 = m_tf->GetOpacity(m_data->GetDensity(ceilf(pos.x),ceilf(pos.y),floorf(pos.z)));
        float a111 = m_tf->GetOpacity(m_data->GetDensity(ceilf(pos.x),ceilf(pos.y),ceilf(pos.z)));

        float difX = abs(pos.x - floorf(pos.x));
        float difY = abs(pos.y - floorf(pos.y));
        float difZ = abs(pos.z - floorf(pos.z));

        float aA = a000*difX + a100*abs(1.0f-difX);
        float aB = a010*difX + a110*abs(1.0f-difX);
        float aC = a011*difX + a111*abs(1.0f-difX);
        float aD = a001*difX + a101*abs(1.0f-difX);

        float aE = aA*difZ + aD*abs(1.0f-difZ);
        float aF = aB*difZ + aC*abs(1.0f-difZ);

        float a = aE*difY + aF*abs(1.0f-difY);
        return a;
}

gradient_t
Trilinear::CalcGradTrilinear(VECTOR pos) {
        gradient_t grad000 = m_data->CalcGrad(floorf(pos.x),floorf(pos.y),floorf(pos.z));
        gradient_t grad001 = m_data->CalcGrad(floorf(pos.x),floorf(pos.y),ceilf(pos.z));
        gradient_t grad010 = m_data->CalcGrad(floorf(pos.x),ceilf(pos.y),floorf(pos.z));
        gradient_t grad011 = m_data->CalcGrad(floorf(pos.x),ceilf(pos.y),ceilf(pos.z));
        gradient_t grad100 = m_data->CalcGrad(ceilf(pos.x),floorf(pos.y),floorf(pos.z));
        gradient_t grad101 = m_data->CalcGrad(ceilf(pos.x),floorf(pos.y),ceilf(pos.z));
        gradient_t grad110 = m_data->CalcGrad(ceilf(pos.x),ceilf(pos.y),floorf(pos.z));
        gradient_t grad111 = m_data->CalcGrad(ceilf(pos.x),ceilf(pos.y),ceilf(pos.z));

        float difX = abs(pos.x - floorf(pos.x));
        float difY = abs(pos.y - floorf(pos.y));
        float difZ = abs(pos.z - floorf(pos.z));

        gradient_t gradA = grad000*difX + grad100*abs(1.0f-difX);
        gradient_t gradB = grad010*difX + grad110*abs(1.0f-difX);
        gradient_t gradC = grad011*difX + grad111*abs(1.0f-difX);
        gradient_t gradD = grad001*difX + grad101*abs(1.0f-difX);

        gradient_t gradE = gradA*difZ + gradD*abs(1.0f-difZ);
        gradient_t gradF = gradB*difZ + gradC*abs(1.0f-difZ);

        gradient_t grad = gradE*difY + gradF*abs(1.0f-difY);
        return grad;
}

Color
Trilinear::CalcColorTrilinear(VECTOR pos) {
        Color col000 = m_tf->GetDensityColor(m_data->GetDensity(floorf(pos.x),floorf(pos.y),floorf(pos.z)));
        Color col001 = m_tf->GetDensityColor(m_data->GetDensity(floorf(pos.x),floorf(pos.y),ceilf(pos.z)));
        Color col010 = m_tf->GetDensityColor(m_data->GetDensity(floorf(pos.x),ceilf(pos.y),floorf(pos.z)));
        Color col011 = m_tf->GetDensityColor(m_data->GetDensity(floorf(pos.x),ceilf(pos.y),ceilf(pos.z)));
        Color col100 = m_tf->GetDensityColor(m_data->GetDensity(ceilf(pos.x),floorf(pos.y),floorf(pos.z)));
        Color col101 = m_tf->GetDensityColor(m_data->GetDensity(ceilf(pos.x),floorf(pos.y),ceilf(pos.z)));
        Color col110 = m_tf->GetDensityColor(m_data->GetDensity(ceilf(pos.x),ceilf(pos.y),floorf(pos.z)));
        Color col111 = m_tf->GetDensityColor(m_data->GetDensity(ceilf(pos.x),ceilf(pos.y),ceilf(pos.z)));


        float difX = abs(pos.x - floorf(pos.x));
        float difY = abs(pos.y - floorf(pos.y));
        float difZ = abs(pos.z - floorf(pos.z));

        Color colA = col000*difX + col100*abs(1.0f-difX);
        Color colB = col010*difX + col110*abs(1.0f-difX);
        Color colC = col011*difX + col111*abs(1.0f-difX);
        Color colD = col001*difX + col101*abs(1.0f-difX);

        Color colE = colA*difZ + colD*abs(1.0f-difZ);
        Color colF = colB*difZ + colC*abs(1.0f-difZ);

        Color col = colE*difY + colF*abs(1.0f-difY);
        return col;
}


Color
Trilinear::Lighting(Color color) {
        gradient_t g = CalcGradTrilinear(m_currentpos);
        VECTOR normal = VECTOR(g.x, g.y, g.z);
        normal.normalize(); // normalize normal
        
        VECTOR len = m_currentpos-m_startpoint;
        Color ret;
        if(m_light) {
                VECTOR v = -m_direction;
                v.normalize();
                VECTOR l = m_lightpos-m_currentpos;
                l.normalize();
                VECTOR h = (v+l);
                h.normalize(); 
                ret = color*m_ambient + color*((m_diffuse*(normal.dot(m_direction))) + (m_specular*pow(normal.dot(h),m_highlight)))+ color/(4.0f+1000000.0f*len.length()); 
        }
        else ret = color*m_ambient + color*(m_diffuse*(normal.dot(m_direction))) + color/(4.0f+1000000.0f*len.length());
        return ret;
}

bool
Trilinear::CastNext() {
        
        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
        
        int step_count = 0;
        bool first = true;
        VECTOR distancetomidpoint = VECTOR(mx/2.0f,my/2.0f,mz/2.0f)-m_currentpos;
        int steps = (int)((distancetomidpoint.length() + m_radius)/m_steplength);
        
        do {
                if(m_alpha > 0.99) break;
                if((m_currentpos.x >= 0.0)&&(m_currentpos.y >= 0.0)&&(m_currentpos.z >= 0.0)&&(m_currentpos.x < mx)&&(m_currentpos.y < my)&&(m_currentpos.z < mz)) {
                        if(first) {
                                m_startpoint = VECTOR(m_currentpos.x,m_currentpos.y,m_currentpos.z);
                                first = false;
                        }
                        Color help_color = CalcColorTrilinear(m_currentpos);
                        float help_alpha = CalcAlphaTrilinear(m_currentpos);
                        // lightning:
                        help_color = Lighting(help_color);
                        // calculate new currentcolor:
                        m_currentcolor += help_color*(1-m_alpha)*help_alpha;
                        // calculate new alphavalue
                        m_alpha += (1-m_alpha)*help_alpha;
                }
                // calculate new position
                m_currentpos += m_steplength*m_direction;
                
                step_count++;
        }while(step_count <= steps);
        if(m_alpha < 1.0 ) {
                m_currentcolor += m_backgroundcolor*(1.0-m_alpha);
        }
        return true;
}




bool
FirstHitNN::CastNext() {
        
        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
        
        int step_count = 0;
        bool first = true;
        VECTOR distancetomidpoint = VECTOR(mx/2.0f,my/2.0f,mz/2.0f)-m_currentpos;
        int steps = (int)((distancetomidpoint.length() + m_radius)/m_steplength);
        do {
                
                if((m_currentpos.x >= 0.0)&&(m_currentpos.y >= 0.0)&&(m_currentpos.z >= 0.0)&&(m_currentpos.x < mx)&&(m_currentpos.y < my)&&(m_currentpos.z < mz)) {
                        if(first) {
                                m_startpoint = VECTOR(m_currentpos.x,m_currentpos.y,m_currentpos.z);
                                first = false;
                        }
                        int d = m_data->GetDensity((int)ROUND(m_currentpos.x),(int)ROUND(m_currentpos.y),(int)ROUND(m_currentpos.z));
                        if(d > m_treshold) {
                                Color help_color = m_tf->GetDensityColor(d);
                                float help_alpha = m_tf->GetOpacity(d);
                                // lightning:
                                help_color = Lighting(help_color);
                                // calculate new currentcolor:
                                m_currentcolor = help_color;
                                // calculate new alphavalue
                                m_alpha = help_alpha;
                                break;
                        }
                }
                // calculate new position
                m_currentpos += m_steplength*m_direction;
                
                step_count++;
        }while(step_count <= steps);
        if(m_alpha < 1.0 ) m_currentcolor += m_backgroundcolor*(1.0 - m_alpha);
        return true;
}

float
FirstHitTRI::GetDensity(VECTOR pos) {
        int dat000 = m_data->GetDensity(floorf(pos.x),floorf(pos.y),floorf(pos.z));
        int dat001 = m_data->GetDensity(floorf(pos.x),floorf(pos.y),ceilf(pos.z));
        int dat010 = m_data->GetDensity(floorf(pos.x),ceilf(pos.y),floorf(pos.z));
        int dat011 = m_data->GetDensity(floorf(pos.x),ceilf(pos.y),ceilf(pos.z));
        int dat100 = m_data->GetDensity(ceilf(pos.x),floorf(pos.y),floorf(pos.z));
        int dat101 = m_data->GetDensity(ceilf(pos.x),floorf(pos.y),ceilf(pos.z));
        int dat110 = m_data->GetDensity(ceilf(pos.x),ceilf(pos.y),floorf(pos.z));
        int dat111 = m_data->GetDensity(ceilf(pos.x),ceilf(pos.y),ceilf(pos.z));

        float difX = abs(pos.x - floorf(pos.x));
        float difY = abs(pos.y - floorf(pos.y));
        float difZ = abs(pos.z - floorf(pos.z));

        int datA = dat000*difX + dat100*abs(1.0f-difX);
        int datB = dat010*difX + dat110*abs(1.0f-difX);
        int datC = dat011*difX + dat111*abs(1.0f-difX);
        int datD = dat001*difX + dat101*abs(1.0f-difX);

        int datE = datA*difZ + datD*abs(1.0f-difZ);
        int datF = datB*difZ + datC*abs(1.0f-difZ);

        int dat = datE*difY + datF*abs(1.0f-difY);
        return dat;
}

bool
FirstHitTRI::CastNext() {
        
        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
        
        int step_count = 0;
        VECTOR distancetomidpoint = VECTOR(mx/2.0f,my/2.0f,mz/2.0f)-m_currentpos;
        int steps = (int)((distancetomidpoint.length() + m_radius)/m_steplength);
        bool first = true;
        do {
                
                if((m_currentpos.x >= 0.0)&&(m_currentpos.y >= 0.0)&&(m_currentpos.z >= 0.0)&&(m_currentpos.x < mx)&&(m_currentpos.y < my)&&(m_currentpos.z < mz)) {
                        if(first) {
                                m_startpoint = VECTOR(m_currentpos.x,m_currentpos.y,m_currentpos.z);
                                first = false;
                        }
                        float d = GetDensity(m_currentpos);
                        if(d > (float)m_treshold) {
                                Color help_color = CalcColorTrilinear(m_currentpos);
                                float help_alpha = CalcAlphaTrilinear(m_currentpos);
                                // lightning:
                                help_color = Lighting(help_color);
                                // calculate new currentcolor:
                                m_currentcolor = help_color;
                                // calculate new alphavalue
                                m_alpha = help_alpha;
                                break;
                        }
                        // calculate new position
                }
                m_currentpos += m_steplength*m_direction;
                step_count++;
        }while(step_count <= steps);
        if(m_alpha < 1.0 ) {
                m_currentcolor += m_backgroundcolor*(1.0f-m_alpha);
        }
        return true;
}


bool
MaxIntensityNN::CastNext() {
        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
        int maxintensity = 0;
        int step_count = 0;
        bool first = true;
        VECTOR distancetomidpoint = VECTOR(mx/2.0f,my/2.0f,mz/2.0f)-m_currentpos;
        int steps = (int)((distancetomidpoint.length() + m_radius)/m_steplength);
        do {
                
                if((m_currentpos.x >= 0.0)&&(m_currentpos.y >= 0.0)&&(m_currentpos.z >= 0.0)&&(m_currentpos.x < mx)&&(m_currentpos.y < my)&&(m_currentpos.z < mz)) {
                        if(first) {
                                m_startpoint = VECTOR(m_currentpos.x,m_currentpos.y,m_currentpos.z);
                                first = false;
                        }
                        int d = m_data->GetDensity((int)ROUND(m_currentpos.x),(int)ROUND(m_currentpos.y),(int)ROUND(m_currentpos.z));
                        if(d > maxintensity) {
                                maxintensity = d;       
                        }
                }
                // calculate new position
                m_currentpos += m_steplength*m_direction;
                
                step_count++;
        }while(step_count <= steps);
        m_light = false;
        m_currentcolor = m_tf->GetDensityColor(maxintensity);
        m_alpha = m_tf->GetOpacity(maxintensity);
        if(maxintensity == 0) {
                m_currentcolor = Color(0,0,0);
                m_alpha = 1.0;
        }
        if(m_alpha < 1.0 ) m_currentcolor += m_backgroundcolor*(1.0 - m_alpha);
        return true;
}

bool
MaxIntensityTRI::CastNext() {
        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
        int maxintensity = 0;
        int step_count = 0;
        VECTOR distancetomidpoint = VECTOR(mx/2.0f,my/2.0f,mz/2.0f)-m_currentpos;
        int steps = (int)((distancetomidpoint.length() + m_radius)/m_steplength);
        bool first = true;
        do {
                
                if((m_currentpos.x >= 0.0)&&(m_currentpos.y >= 0.0)&&(m_currentpos.z >= 0.0)&&(m_currentpos.x < mx)&&(m_currentpos.y < my)&&(m_currentpos.z < mz)) {
                        if(first) {
                                m_startpoint = VECTOR(m_currentpos.x,m_currentpos.y,m_currentpos.z);
                                first = false;
                        }
                        float d = GetDensity(m_currentpos);
                        if(d > (float)maxintensity) {
                                maxintensity = d;
                        }
                        // calculate new position
                }
                m_currentpos += m_steplength*m_direction;
                step_count++;
        }while(step_count <= steps);

        m_currentcolor = m_tf->GetDensityColor(maxintensity);
        m_alpha = m_tf->GetOpacity(maxintensity);
        if(maxintensity == 0) {
                m_currentcolor = Color(0,0,0);
                m_alpha = 1.0;
        }
        if(m_alpha < 1.0 ) {
                m_currentcolor += m_backgroundcolor*(1.0f-m_alpha);
        }
        return true;
}

bool
XRayNN::CastNext() {
        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
        int density = 0;
        int step_count = 0;
        bool first = true;
        VECTOR distancetomidpoint = VECTOR(mx/2.0f,my/2.0f,mz/2.0f)-m_currentpos;
        int steps = (int)((distancetomidpoint.length() + m_radius)/m_steplength);
        do {
                
                if((m_currentpos.x >= 0.0)&&(m_currentpos.y >= 0.0)&&(m_currentpos.z >= 0.0)&&(m_currentpos.x < mx)&&(m_currentpos.y < my)&&(m_currentpos.z < mz)) {
                        if(first) {
                                m_startpoint = VECTOR(m_currentpos.x,m_currentpos.y,m_currentpos.z);
                                first = false;
                        }
                        int d = m_data->GetDensity((int)ROUND(m_currentpos.x),(int)ROUND(m_currentpos.y),(int)ROUND(m_currentpos.z));
                        density += d*m_steplength;      
                }
                // calculate new position
                m_currentpos += m_steplength*m_direction;
                
                step_count++;
        }while(step_count <= steps);
        m_currentcolor = m_tf->GetDensityColor(density);
        m_alpha = m_tf->GetOpacity(density);
        if(density == 0) {
                m_currentcolor = Color(0,0,0);
                m_alpha = 1.0;
        }
        if(m_alpha < 1.0 ) m_currentcolor += m_backgroundcolor*(1.0 - m_alpha);
        return true;
}

bool
XRayTRI::CastNext() {
        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
        int density = 0;
        int step_count = 0;
        VECTOR distancetomidpoint = VECTOR(mx/2.0f,my/2.0f,mz/2.0f)-m_currentpos;
        int steps = (int)((distancetomidpoint.length() + m_radius)/m_steplength);
        bool first = true;
        do {
                
                if((m_currentpos.x >= 0.0)&&(m_currentpos.y >= 0.0)&&(m_currentpos.z >= 0.0)&&(m_currentpos.x < mx)&&(m_currentpos.y < my)&&(m_currentpos.z < mz)) {
                        if(first) {
                                m_startpoint = VECTOR(m_currentpos.x,m_currentpos.y,m_currentpos.z);
                                first = false;
                        }
                        float d = GetDensity(m_currentpos);
                        density += d*m_steplength; 
                        // calculate new position
                }
                m_currentpos += m_steplength*m_direction;
                step_count++;
        }while(step_count <= steps);

        m_currentcolor = m_tf->GetDensityColor(density);
        m_alpha = m_tf->GetOpacity(density);
        if(density == 0) {
                m_currentcolor = Color(0,0,0);
                m_alpha = 1.0;
        }
        if(m_alpha < 1.0 ) {
                m_currentcolor += m_backgroundcolor*(1.0f-m_alpha);
        }
        return true;
}

bool
AverageNN::CastNext() {
        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
        int sum = 0;
        int counter = 0;
        int step_count = 0;
        bool first = true;
        VECTOR distancetomidpoint = VECTOR(mx/2.0f,my/2.0f,mz/2.0f)-m_currentpos;
        int steps = (int)((distancetomidpoint.length() + m_radius)/m_steplength);
        do {
                
                if((m_currentpos.x >= 0.0)&&(m_currentpos.y >= 0.0)&&(m_currentpos.z >= 0.0)&&(m_currentpos.x < mx)&&(m_currentpos.y < my)&&(m_currentpos.z < mz)) {
                        if(first) {
                                m_startpoint = VECTOR(m_currentpos.x,m_currentpos.y,m_currentpos.z);
                                first = false;
                        }
                        int d = m_data->GetDensity((int)ROUND(m_currentpos.x),(int)ROUND(m_currentpos.y),(int)ROUND(m_currentpos.z));
                        sum += d;
                        counter++;
                }
                // calculate new position
                m_currentpos += m_steplength*m_direction;
                
                step_count++;
        }while(step_count <= steps);
        int density = ROUND(sum/counter);
        m_currentcolor = m_tf->GetDensityColor(density);
        m_alpha = m_tf->GetOpacity(density);
        if(density == 0) {
                m_currentcolor = Color(0,0,0);
                m_alpha = 1.0;
        }
        if(m_alpha < 1.0 ) m_currentcolor += m_backgroundcolor*(1.0 - m_alpha);
        return true;
}

bool
AverageTRI::CastNext() {
        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
        int sum = 0;
        int counter = 0;
        int step_count = 0;
        VECTOR distancetomidpoint = VECTOR(mx/2.0f,my/2.0f,mz/2.0f)-m_currentpos;
        int steps = (int)((distancetomidpoint.length() + m_radius)/m_steplength);
        bool first = true;
        do {
                
                if((m_currentpos.x >= 0.0)&&(m_currentpos.y >= 0.0)&&(m_currentpos.z >= 0.0)&&(m_currentpos.x < mx)&&(m_currentpos.y < my)&&(m_currentpos.z < mz)) {
                        if(first) {
                                m_startpoint = VECTOR(m_currentpos.x,m_currentpos.y,m_currentpos.z);
                                first = false;
                        }
                        float d = GetDensity(m_currentpos);
                        sum += (int)d;
                        counter++;
                        
                }
                m_currentpos += m_steplength*m_direction;
                step_count++;
        }while(step_count <= steps);
        int density = ROUND(sum/counter);
        m_currentcolor = m_tf->GetDensityColor(density);
        m_alpha = m_tf->GetOpacity(density);
        if(density == 0) {
                m_currentcolor = Color(0,0,0);
                m_alpha = 1.0;
        }
        if(m_alpha < 1.0 ) {
                m_currentcolor += m_backgroundcolor*(1.0f-m_alpha);
        }
        return true;
}

---