---

ray.h

Go to the documentation of this file.

#ifndef RAY_H 
#define RAY_H

#include <assert.h>
#include "vector.h"
#include "transfunc.h"
#include "data.h"
#include "plane.h"


#define ROUND(x) (((fabs(x - floor(x))) < 0.5) ? floor(x) : ceil(x))

class Ray {
        protected:
                bool m_light;
                VECTOR m_lightpos;
                // calculates shading nearest neighbour
                virtual Color Lighting(Color color);
                
                // recent position
                VECTOR m_currentpos;
                // ambient lighting coefficient
                float m_ambient;
                // diffuses lighting coefficient
                float m_diffuse;

                float m_specular;

                int m_highlight;
                // transferfunction
                Transfunc *m_tf;
            // datavolume
                Data *m_data;
                // backgroundcolor
                Color m_backgroundcolor;
                // recent color
                Color m_currentcolor;
                // recent alpha
                float m_alpha;
                // startpoint
                VECTOR m_startpoint;
                // direction vector
                VECTOR m_direction;
                float m_steplength;
                Plane * m_viewingplane;
                
                float mx,my,mz, m_radius;
        public:
                Ray(); 
                ~Ray();
                // sets viewingcondition
                bool SetViewingCondition(VECTOR lightpos, float ambient, float diffuse, float specular, int highlight);
                // init ray
                bool Initialize(Color background, Color current, float steplength, Plane* viewingplane, Data *data, Transfunc *tf);
                bool SetPosDir(VECTOR currentpos, VECTOR direction);
                Color GetCurrentColor();
                float GetAlpha() { return m_alpha;};
                void SetLight(bool light) { m_light = light;};
                virtual bool CastNext();
                bool Reset() {m_alpha = 0.0; m_currentcolor = m_backgroundcolor; return true;};
};

class Trilinear : public Ray {
protected:
        Color CalcColorTrilinear(VECTOR pos);
        gradient_t CalcGradTrilinear(VECTOR pos);
        float CalcAlphaTrilinear(VECTOR pos);
        Color Lighting(Color color); // methode calculates shading
        
public:
        Trilinear() {};
        bool CastNext();
};




class FirstHitNN : public Ray {
protected:
        int m_treshold;
public:
        FirstHitNN(){m_treshold = 0.0;};
        bool SetTreshold(int treshold) { m_treshold = treshold; return true;};
        virtual bool CastNext();
};

class FirstHitTRI : public Trilinear {
protected:
        int m_treshold;
        float GetDensity(VECTOR pos);
public:
        FirstHitTRI(){m_treshold = 0.0;};
        bool SetTreshold(int treshold) { m_treshold = treshold; return true;};
        bool CastNext();
};


class MaxIntensityNN : public Ray {     
public:
        MaxIntensityNN(){};
        ~MaxIntensityNN(){};
        bool CastNext();
};



class MaxIntensityTRI : public FirstHitTRI {    
public:
        MaxIntensityTRI(){};
        ~MaxIntensityTRI(){};
        bool CastNext();
};

class XRayNN : public Ray {
public:
        XRayNN(){};
        ~XRayNN(){};
        bool CastNext();
};

class XRayTRI : public FirstHitTRI {
public:
        XRayTRI(){};
        ~XRayTRI(){};
        bool CastNext();
};

class AverageNN : public Ray {
public:
        AverageNN(){};
        ~AverageNN(){};
        bool CastNext();
};

class AverageTRI : public FirstHitTRI {
public:
        AverageTRI(){};
        ~AverageTRI(){};
        bool CastNext();
};

#endif

---