---

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_viewingplane = NULL;
        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;
}

Raycaster::~Raycaster() {
        if(m_image != NULL) delete m_image;
        if(m_viewingplane != NULL) delete m_viewingplane;
        if(m_viewingtoworld != NULL) delete m_viewingtoworld;
        m_image = NULL;
        m_viewingplane = 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(VECTOR viewingplanepos, 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;
        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);

        //set zoom and viewingtoworld matrix
        Zoom(m_zoom);


        if(m_viewingplane == NULL) return false;
        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
        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];
        
        VECTOR pos =  m_viewingplane->point-m_width/2*m_xdir-m_height/2*m_ydir;
        VECTOR backup = pos;
        
        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();
                        break;
        }
        
        r->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
        r->Initialize(m_background,m_background,m_steplength,m_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, m_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);
        
        }

        
/*
        Ray *r;
        Trilinear *tri;
        FirstHitNN *fhnn;
        FirstHitTRI *fhtri;
        MaxIntensityNN *minn;
        MaxIntensityTRI *mitri;
        XRayNN *xraynn;
        XRayTRI *xraytri;

        if(m_raytype == NN && m_rendermode == STANDARD) {
                r = new Ray();
                r->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                r->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
                r->SetLight(m_light);
        }
        if(m_raytype == TRI && m_rendermode == STANDARD) {
                tri = new Trilinear();
                tri->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                tri->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
                tri->SetLight(m_light);
        }
        if(m_raytype == NN && m_rendermode == FH) {
                fhnn = new FirstHitNN();
                fhnn->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                fhnn->SetTreshold(m_treshold);
                fhnn->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
                fhnn->SetLight(m_light);
        }
        if(m_raytype == TRI && m_rendermode == FH) {
                fhtri = new FirstHitTRI();
                fhtri->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                fhtri->SetTreshold(m_treshold);
                fhtri->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
                fhtri->SetLight(m_light);
        }
        if(m_raytype == NN && m_rendermode == MI) {
                minn = new MaxIntensityNN();
                minn->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                minn->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
        }
        if(m_raytype == TRI && m_rendermode == MI) {
                mitri = new MaxIntensityTRI();
                mitri->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                mitri->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
        }
        if(m_raytype == NN && m_rendermode == XRAY) {
                xraynn = new XRayNN();
                xraynn->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                xraynn->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
        }
        if(m_raytype == TRI && m_rendermode == XRAY) {
                xraytri = new XRayTRI();
                xraytri->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                xraytri->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
        }

        
        for(int j = 0; j < m_height; j++) {
                for(int i = 0; i < m_width; i++) {
                        if(m_raytype == NN && m_rendermode == STANDARD) {
                                r->Reset();
                                r->SetPosDir(pos,m_viewingplane->normal);
                                r->CastNext();
                                m_image[j*m_width+i] = r->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == TRI && m_rendermode == STANDARD) {
                                tri->Reset();
                                tri->SetPosDir(pos,m_viewingplane->normal);
                                tri->CastNext();
                                m_image[j*m_width+i] = tri->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == NN && m_rendermode == FH) {
                                fhnn->Reset();
                                fhnn->SetPosDir(pos,m_viewingplane->normal);
                                fhnn->CastNext();
                                m_image[j*m_width+i] = fhnn->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == TRI && m_rendermode == FH) {
                                fhtri->Reset();
                                fhtri->SetPosDir(pos,m_viewingplane->normal);
                                fhtri->CastNext();
                                m_image[j*m_width+i] = fhtri->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == NN && m_rendermode == MI) {
                                minn->Reset();
                                minn->SetPosDir(pos,m_viewingplane->normal);
                                minn->CastNext();
                                m_image[j*m_width+i] = minn->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == TRI && m_rendermode == MI) {
                                mitri->Reset();
                                mitri->SetPosDir(pos,m_viewingplane->normal);
                                mitri->CastNext();
                                m_image[j*m_width+i] = mitri->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == NN && m_rendermode == XRAY) {
                                xraynn->Reset();
                                xraynn->SetPosDir(pos,m_viewingplane->normal);
                                xraynn->CastNext();
                                m_image[j*m_width+i] = xraynn->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == TRI && m_rendermode == XRAY) {
                                xraytri->Reset();
                                xraytri->SetPosDir(pos,m_viewingplane->normal);
                                xraytri->CastNext();
                                m_image[j*m_width+i] = xraytri->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);
        if(m_viewingtoworld == NULL) m_viewingtoworld = new Matrix4x4();
        m_viewingtoworld->rotation(zaxis,m_viewingplane->normal);

        m_xdir = VECTOR(1,0,0);
        m_ydir = VECTOR(0,1,0);

        m_xdir = *m_viewingtoworld*m_xdir;
        m_ydir = *m_viewingtoworld*m_ydir;
        m_xdir.normalize();
        m_ydir.normalize();
        m_xdir = m_stepX * m_xdir;
        m_ydir = m_stepY * m_ydir;

        return true;
}
        
bool
Raycaster::RotateX(float alpha) {
        Matrix4x4 rotmat;
        rotmat.rotateX(-alpha);
        m_viewingplane->point = rotmat*m_viewingplane->point;
        int maxX = m_data->GetXDim()-1;
        int maxY = m_data->GetYDim()-1;
        int maxZ = m_data->GetZDim()-1;
        m_viewingplane->normal = VECTOR(maxX/2,maxY/2,maxZ/2)-m_viewingplane->point;
        m_viewingplane->normal.normalize();
        SetViewingMatrix();
        return true;
}

bool
Raycaster::RotateY(float alpha) {
        Matrix4x4 rotmat;
        rotmat.rotateY(-alpha);
        m_viewingplane->point = rotmat*m_viewingplane->point;
        int maxX = m_data->GetXDim()-1;
        int maxY = m_data->GetYDim()-1;
        int maxZ = m_data->GetZDim()-1;
        m_viewingplane->normal = VECTOR(maxX/2,maxY/2,maxZ/2)-m_viewingplane->point;
        m_viewingplane->normal.normalize();
        SetViewingMatrix();
        return true;
}

bool
Raycaster::RotateZ(float alpha) {
        Matrix4x4 rotmat;
        rotmat.rotateZ(-alpha);
        m_viewingplane->point = rotmat*m_viewingplane->point;
        int maxX = m_data->GetXDim()-1;
        int maxY = m_data->GetYDim()-1;
        int maxZ = m_data->GetZDim()-1;
        m_viewingplane->normal = VECTOR(maxX/2,maxY/2,maxZ/2)-m_viewingplane->point;
        m_viewingplane->normal.normalize();
        SetViewingMatrix();
        return true;
}


Perspective::Perspective() {
        m_eye = VECTOR(0,0,-10);
        m_dist = 0;

        m_dOwnType = PERSPECTIVE;
}

Perspective::~Perspective() {}

bool
Perspective::Initialize(VECTOR eye, float dist, int width, int height,float steplength,Data *data,Transfunc *tf) {
        m_eye = eye;
        m_data = data;
        m_tf = tf;
        m_width = width;
        m_height = height;
        m_steplength = steplength;
        m_dist = dist;
        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)-m_eye;
        viewingplanenormal.normalize();

        VECTOR viewingplanepos = m_eye + m_dist * viewingplanenormal;
        m_viewingplane = new Plane(viewingplanenormal,viewingplanepos);

        Zoom(m_zoom);

        if(m_viewingplane == NULL) return false;
        if(m_data == NULL) return false;
        if(m_tf == NULL) return false;
        return true;
}


bool
Perspective::Raycast() {

        CWnd* pFrame = AfxGetMainWnd();


        m_data->SetPreCalc(m_precalc);
        m_image = new rgb[m_width*m_height];
        
        VECTOR pos =  m_viewingplane->point-m_width/2*m_xdir-m_height/2*m_ydir;
        VECTOR backup = pos;

        VECTOR direction;
        
        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();
                        break;
        }
        
        r->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
        r->Initialize(m_background,m_background,m_steplength,m_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();
                        direction = pos-m_eye;
                        r->SetPosDir(m_eye,direction);
                        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);
        
        }





/*
        Ray *r;
        Trilinear *tri;
        FirstHitNN *fhnn;
        FirstHitTRI *fhtri;
        MaxIntensityNN *minn;
        MaxIntensityTRI *mitri;
        XRayNN *xraynn;
        XRayTRI *xraytri;

        if(m_raytype == NN && m_rendermode == STANDARD) {
                r = new Ray();
                r->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                r->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
                r->SetLight(m_light);
        }
        if(m_raytype == TRI && m_rendermode == STANDARD) {
                tri = new Trilinear();
                tri->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                tri->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
                tri->SetLight(m_light);
        }
        if(m_raytype == NN && m_rendermode == FH) {
                fhnn = new FirstHitNN();
                fhnn->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                fhnn->SetTreshold(m_treshold);
                fhnn->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
                fhnn->SetLight(m_light);
        }
        if(m_raytype == TRI && m_rendermode == FH) {
                fhtri = new FirstHitTRI();
                fhtri->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                fhtri->SetTreshold(m_treshold);
                fhtri->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
                fhtri->SetLight(m_light);
        }
        if(m_raytype == NN && m_rendermode == MI) {
                minn = new MaxIntensityNN();
                minn->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                minn->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
        }
        if(m_raytype == TRI && m_rendermode == MI) {
                mitri = new MaxIntensityTRI();
                mitri->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                mitri->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
        }
        if(m_raytype == NN && m_rendermode == XRAY) {
                xraynn = new XRayNN();
                xraynn->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                xraynn->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
        }
        if(m_raytype == TRI && m_rendermode == XRAY) {
                xraytri = new XRayTRI();
                xraytri->SetViewingCondition(m_lightpos, m_ambient, m_diffuse, m_specular, m_highlight);
                xraytri->Initialize(m_background,m_background,m_steplength,m_viewingplane,m_data,m_tf);
        }
        
        for(int j = 0; j < m_height; j++) {
                for(int i = 0; i < m_width; i++) {
                        if(m_raytype == NN && m_rendermode == STANDARD) {
                                r->Reset();
                                direction = pos-m_eye;
                                r->SetPosDir(m_eye,direction);
                                r->CastNext();
                                m_image[j*m_width+i] = r->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == TRI && m_rendermode == STANDARD) {
                                tri->Reset();
                                direction = pos-m_eye;
                                tri->SetPosDir(m_eye,direction);
                                tri->CastNext();
                                m_image[j*m_width+i] = tri->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == NN && m_rendermode == FH) {
                                fhnn->Reset();
                                direction = pos-m_eye;
                                fhnn->SetPosDir(m_eye,direction);
                                fhnn->CastNext();
                                m_image[j*m_width+i] = fhnn->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == TRI && m_rendermode == FH) {
                                fhtri->Reset();
                                direction = pos-m_eye;
                                fhtri->SetPosDir(m_eye,direction);
                                fhtri->CastNext();
                                m_image[j*m_width+i] = fhtri->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == NN && m_rendermode == MI) {
                                minn->Reset();
                                direction = pos-m_eye;
                                minn->SetPosDir(m_eye,direction);
                                minn->CastNext();
                                m_image[j*m_width+i] = minn->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == TRI && m_rendermode == MI) {
                                mitri->Reset();
                                direction = pos-m_eye;
                                mitri->SetPosDir(m_eye,direction);
                                mitri->CastNext();
                                m_image[j*m_width+i] = mitri->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == NN && m_rendermode == XRAY) {
                                xraynn->Reset();
                                direction = pos-m_eye;
                                xraynn->SetPosDir(m_eye,direction);
                                xraynn->CastNext();
                                m_image[j*m_width+i] = xraynn->GetCurrentColor().toRGB();
                        }
                        if(m_raytype == TRI && m_rendermode == XRAY) {
                                xraytri->Reset();
                                direction = pos-m_eye;
                                xraytri->SetPosDir(m_eye,direction);
                                xraytri->CastNext();
                                m_image[j*m_width+i] = xraytri->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
Perspective::RotateX(float alpha) {
        int maxX = m_data->GetXDim()-1;
        int maxY = m_data->GetYDim()-1;
        int maxZ = m_data->GetZDim()-1;
        Matrix4x4 rotmat;
        rotmat.rotateX(-alpha);
        m_eye = rotmat*m_eye;
        m_viewingplane->normal = VECTOR(maxX/2,maxY/2,maxZ/2)-m_eye;
        m_viewingplane->normal.normalize();
        m_viewingplane->point = m_eye + m_dist*m_viewingplane->normal;
        
        SetViewingMatrix();
        return true;
}

bool
Perspective::RotateY(float alpha) {
        int maxX = m_data->GetXDim()-1;
        int maxY = m_data->GetYDim()-1;
        int maxZ = m_data->GetZDim()-1;
        Matrix4x4 rotmat;
        rotmat.rotateY(-alpha);
        m_eye = rotmat*m_eye;
        m_viewingplane->normal = VECTOR(maxX/2,maxY/2,maxZ/2)-m_eye;
        m_viewingplane->normal.normalize();
        m_viewingplane->point = m_eye + m_dist*m_viewingplane->normal;
        
        SetViewingMatrix();
        return true;
}

bool
Perspective::RotateZ(float alpha) {
        int maxX = m_data->GetXDim()-1;
        int maxY = m_data->GetYDim()-1;
        int maxZ = m_data->GetZDim()-1;
        Matrix4x4 rotmat;
        rotmat.rotateZ(-alpha);
        m_eye = rotmat*m_eye;
        m_viewingplane->normal = VECTOR(maxX/2,maxY/2,maxZ/2)-m_eye;
        m_viewingplane->normal.normalize();
        m_viewingplane->point = m_eye + m_dist*m_viewingplane->normal;
        
        SetViewingMatrix();
        return true;
}

---