RayCaster.h

Go to the documentation of this file.

// vim:set ts=4 sw=4 noet cin:

#ifndef RAYCASTER_H_
#define RAYCASTER_H_

#include "ARender.h"
#include "Vector.h"
#include "Data.h"
#include "Size.h"
#include "Plane.h"
#include "Lighting.h"
#include "Gradient.h"

enum RenderMode{
        RM_FrontToBack, 

        RM_BackToFront  
};

enum InterpolationMode{
        IM_NearestNeighbour,    
        IM_Trilinear                    

};



class RayCaster : public ARender {
        public:
                RayCaster(      Data& aData, Gradient& aGradient, Size s = Size(1,1), Color bgColor = Color(0,0,0,255), 
                                        RenderMode renderMode = RM_FrontToBack, InterpolationMode interpolationMode = IM_NearestNeighbour);
                ~RayCaster();

                void setViewerPosition(const Vector<>& A, const Vector<>& B,
                                                           const Vector<>& C);
                
                void setImageSize(const Size& s);

                // ARender
                virtual Color getPixelColor(unsigned int x, unsigned int y);
                virtual Size getImageSize() const;
                virtual void render(unsigned char* buffer);
                
                void setRenderMode(RenderMode newRenderMode);
                RenderMode getRenderMode() const;

                void setInterpolationMode(InterpolationMode newInterpolationMode);
                InterpolationMode getInterpolationMode() const;

                void setBGColor(Color newBGColor);
                Color getBGColor() const;

                void setSampleRate(float newRate);
                float getSampleRate() const;

                void enableLighting();
                void disableLighting();
                bool isLightingEnabled() const;

                Lighting* lighting();

        protected:
                Color applyTransferFunctions(unsigned short aDataValue, const Vector<>& gradient) const;
        private:
                void calcVectors();
                std::auto_ptr< Vector<> > intersectRayWithNearestPlane  (const Vector<>& startPos, const Vector<>& direction) const;
                std::auto_ptr< Vector<> > intersectRayWithFarthestPlane (const Vector<>& startPos, const Vector<>& direction) const;
                
                unsigned short getDataAt(float x, float y, float z) const {
                        // Nearest neigbour for now (XXX make that configurable)
                        return mData.getData(int(x), int(y), int(z));
                }
                
                unsigned short getDataTrilinearInterpolated(float x, float y, float z){
                        return mData.getDataTrilinearInterpolated(x,y,z);
                }
                
                Vector<> getGradientAt(float x, float y, float z) const{
                        return mGradient.getData(int(x), int(y), int(z));               
                }

                Vector<> getGradientTrilinearInterpolated(float x, float y, float z){
                        return mGradient.getDataTrilinearInterpolated(x,y,z);
                }
                

                Color getPixelColor_FrontToBack(unsigned int x, unsigned int y);        //is used if mRenderMode = RM_FrontToBack
                Color getPixelColor_BackToFront(unsigned int x, unsigned int y);        //is used if mRenderMode = RM_BackToFront

                void render_FrontToBack(unsigned char* buffer);         //is used if mRenderMode = RM_FrontToBack
                void render_BackToFront(unsigned char* buffer);         //is used if mRenderMode = RM_BackToFront
                
                void compositeBackToFront(Color& dest, const Color& src) {
                        float fR = dest.R() / float(255);
                        float fG = dest.G() / float(255);
                        float fB = dest.B() / float(255);

                        float sR = src.R() / float(255);
                        float sG = src.G() / float(255);
                        float sB = src.B() / float(255);
                        float sA = src.A() / float(255);

                        dest.setR((Color::ColorUnit) (255 * (fR * (1 - sA) + sR * sA)));
                        dest.setG((Color::ColorUnit) (255 * (fG * (1 - sA) + sG * sA)));
                        dest.setB((Color::ColorUnit) (255 * (fB * (1 - sA) + sB * sA)));
                }

                void compositeFrontToBack(Color& dest, const Color& src) {
//                      float fR = dest.R() / float(255);
//                      float fG = dest.G() / float(255);
//                      float fB = dest.B() / float(255);
                        float fA = dest.A() / float(255);
                        
                        float sR = src.R() / float(255);
                        float sG = src.G() / float(255);
                        float sB = src.B() / float(255);
                        float sA = src.A() / float(255);

                        dest.setR((Color::ColorUnit) (dest.R() + 255 * (sR * ((1-fA) * sA))));
                        dest.setG((Color::ColorUnit) (dest.G() + 255 * (sG * ((1-fA) * sA))));
                        dest.setB((Color::ColorUnit) (dest.B() + 255 * (sB * ((1-fA) * sA))));

//                      int totalA = dest.A() + src.A();
//                      if (totalA>Color::maxChannelValue) dest.setA(Color::maxChannelValue);
//                      else dest.setA(totalA);

//                      dest.setG(255 * (fG * fA + sG * ((1-fA) * sA)));
//                      dest.setB(255 * (fB * fA + sB * ((1-fA) * sA)));

                        dest.setA((Color::ColorUnit) (255 * (fA + (1-fA) * sA)));
                }

                Data& mData;
                Gradient& mGradient;
                Size mImageSize;
                Vector<> mTopLeft, mTopRight, mLowerRight, mViewingDirection;
                
                // Vectors for moving from the topleft point to the right and to the
                // bottom. These are affected by mImageSize.
                Vector<> mRightVec, mDownVec;
                
                Lighting mLighting;
                
                Color mBGColor;

                RenderMode mRenderMode;
                
                InterpolationMode mInterpolationMode;
                float mSampleRate;
                bool mEnableLighting;

                const Vector<> mMaxDataVector;  //upper Bound to all Voxel-Position.
                
                // 6 planes...                          //needed in intersectRay* functions
                const Plane mFrontPlane;
                const Plane mBackPlane;

                const Plane mTopPlane;
                const Plane mBottomPlane;

                const Plane mLeftPlane;
                const Plane mRightPlane;

};

#endif

---