---

raycaster.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "raycaster.h"

#include "messages.h"


Raycaster::Raycaster() {
        ready = false;
        
        m_specular = 0.2f;
        m_highlight = 8;
        m_lightpos = VECTOR(300,300,300);
        m_light = false;
        m_image = NULL;
        m_ambient = 0.2f;
        m_diffuse = 0.2f;
        m_height = 0;
        m_width = 0;
        m_viewingtoworld = NULL;
        m_stepX = 1.0;
        m_stepY = 1.0;
        m_data = NULL;
        m_tf = NULL;
        m_xdir = VECTOR(1,0,0);
        m_ydir = VECTOR(0,1,0);
        m_treshold = 1500;
        m_rendermode = STANDARD;
        m_raytype = NN;
        m_precalc = false;
        m_zoom = 1.0;

        m_dOwnType = RAYCASTER;

        m_dMaxDens = 4095;
        m_dMinDens = 0;
}

Raycaster::~Raycaster() {
        if(m_image != NULL) delete m_image;
        if(m_viewingtoworld != NULL) delete m_viewingtoworld;
        m_image = NULL;
        m_viewingtoworld = NULL;
}

bool
Raycaster::SetViewingCondition(VECTOR lightpos, Color background, float ambient, float diffuse, float specular, int highlight) {
        m_ambient = ambient;
        m_diffuse = diffuse;
        m_background = background;
        m_specular = specular;
        m_highlight = highlight;
        m_lightpos = lightpos;
        return true;
}


bool
Raycaster::Render(int width, int height) {

        int m_x = width / 2 - m_width / 2;
        int m_y = height / 2 - m_height / 2;


        if (!ready)
                return false;

        glRasterPos2i(m_x, m_y);
        glPixelStorei(GL_UNPACK_ALIGNMENT,1);
        glDrawPixels(m_width, m_height, GL_RGB, GL_UNSIGNED_BYTE, m_image);
        return true;
}

bool
Raycaster::Initialize(int width, int height, float steplength, Data *data, Transfunc *tf) {
        m_data = data;
        m_tf = tf;
        m_width = width;
        m_height = height;
        m_steplength = steplength;
        return true;
}

/*
void Raycaster::SetViewingPlanePos(float x, float y, float z) {
        if (!m_data)
                return;
        
        VECTOR viewingplanepos = VECTOR(x, y, z);
        int maxX = m_data->GetXDim()-1;
        int maxY = m_data->GetYDim()-1;
        int maxZ = m_data->GetZDim()-1;
        VECTOR viewingplanenormal = VECTOR(maxX/2,maxY/2,maxZ/2)-viewingplanepos;
        viewingplanenormal.normalize();
        m_viewingplane = new Plane(viewingplanenormal,viewingplanepos);
}
*/



bool
Raycaster::Raycast() {

        CWnd* pFrame = AfxGetMainWnd();


        m_data->SetPreCalc(m_precalc);
        m_image = new rgb[m_width*m_height];
        
        int maxX = m_data->GetXDim();
        int maxY = m_data->GetYDim();
        int maxZ = m_data->GetZDim();

        VECTOR pos =  VECTOR(0,0,0);
        Matrix4x4 trans;
        trans.translate(VECTOR(-maxX/2,-maxY/2,-maxZ/2));
        pos = trans * pos;
        pos = *m_viewingtoworld_inv * pos;
        trans.translate(VECTOR(maxX/2,maxY/2,maxZ/2));
        pos = trans*pos;
        VECTOR backup = pos;

        VECTOR normal = VECTOR(0,0,0)-pos;
        if(normal.x == 0 && normal.y == 0 && normal.z == 0)
                normal.z = 1.0;

        Plane *viewingplane = new Plane(normal,pos);
        m_xdir = *m_viewingtoworld_inv * m_xdir;
        m_ydir = *m_viewingtoworld_inv * m_ydir;
        
        int loadSize = (m_height * m_width) / 100;
        int counter = loadSize / 100;
        int progPos = 0;



        Ray *r;
        switch (m_rendermode) {
                case STANDARD:
                        if (m_raytype == NN)
                                r = new Ray();
                        else if (m_raytype == TRI)
                                r = new Trilinear();
                        break;
                case FH:
                        if (m_raytype == NN) {
                                r = new FirstHitNN();
                                ((FirstHitNN *)r)->SetTreshold(m_treshold);
                        }
                        else if (m_raytype == TRI) {
                                r = new FirstHitTRI();
                                ((FirstHitTRI *)r)->SetTreshold(m_treshold);
                        }
                        break;
                case MI:
                        if (m_raytype == NN)
                                r = new MaxIntensityNN();
                        else if (m_raytype == TRI)
                                r = new MaxIntensityTRI();
                        break;
                case XRAY:
                        if (m_raytype == NN)
                                r = new XRayNN();
                        else if (m_raytype == TRI)
                                r = new XRayTRI();
                        
                        r->SetDensRange(m_dMinDens, m_dMaxDens);
                        break;
        }

        r->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
        r->Initialize(m_background,m_background,m_steplength,viewingplane,m_data,m_tf);
        r->SetLight(m_light);

        for(int j = 0; j < m_height; j++) {
                for(int i = 0; i < m_width; i++) {
                        r->Reset();
                        r->SetPosDir(pos, viewingplane->normal);
                        r->CastNext();
                        m_image[j * m_width + i] = r->GetCurrentColor().toRGB();

                        pos += m_xdir;

                        if ((counter-- <= 0) && (progPos < 100)) {
                                counter = loadSize;
                                pFrame->SendMessage(MYWM_PROGRESS, progPos++);
                        }


                } // inner for
                pos = backup;
                pos += j*m_ydir;

                pFrame->SendMessage(MYWM_PROGRESS, 0);
        
        }

        

        if (r)
                delete r;
        
        ready = true;
        return true;
}


bool
Raycaster::Zoom(float zoom) {
        int maxX = m_data->GetXDim()-1;
        int maxY = m_data->GetYDim()-1;
        int maxZ = m_data->GetZDim()-1;
        m_zoom = zoom;
        float maxlength = sqrtf(powf((float)maxX,2.0)+powf((float)maxY,2.0)+powf((float)maxZ,2.0));
        m_stepX = (1/m_zoom)*maxlength/(m_width-1);
        m_stepY = (1/m_zoom)*maxlength/(m_height-1);

        SetViewingMatrix();
        return true;
}


bool
Raycaster::SetViewingMatrix() {
        VECTOR zaxis = VECTOR(0,0,1);
        m_viewingtoworld = new Matrix4x4();
        m_viewingtoworld->identity();
        m_viewingtoworld_inv = new Matrix4x4();
        m_viewingtoworld_inv->identity();
        m_xdir = VECTOR(1,0,0);
        m_ydir = VECTOR(0,1,0);

        m_xdir = m_stepX * m_xdir;
        m_ydir = m_stepY * m_ydir;

        return true;
}
        
bool
Raycaster::RotateX(float alpha) {
        Matrix4x4 rotmat1;
        Matrix4x4 rotmat2;
        rotmat1.rotateX(alpha);
        rotmat2.rotateX(-alpha);
        
        *m_viewingtoworld = m_viewingtoworld->mul(rotmat1);
        *m_viewingtoworld_inv = m_viewingtoworld_inv->mul(rotmat2);
        return true;
}

bool
Raycaster::RotateY(float alpha) {
        Matrix4x4 rotmat1;
        Matrix4x4 rotmat2;
        rotmat1.rotateY(alpha);
        rotmat2.rotateY(-alpha);
        
        *m_viewingtoworld = m_viewingtoworld->mul(rotmat1);
        *m_viewingtoworld_inv = m_viewingtoworld_inv->mul(rotmat2);
        return true;
}

bool
Raycaster::RotateZ(float alpha) {
        Matrix4x4 rotmat1;
        Matrix4x4 rotmat2;
        rotmat1.rotateZ(alpha);
        rotmat2.rotateZ(-alpha);
        
        *m_viewingtoworld = m_viewingtoworld->mul(rotmat1);
        *m_viewingtoworld_inv = m_viewingtoworld_inv->mul(rotmat2);
        return true;
}

---