Changeset 1960

Timestamp:

01/10/07 02:10:23 (17 years ago)

Author:

mattausch

Message:

worked on depth peeling

Location:

GTP/trunk/Lib/Vis/Preprocessing/src

Files:

• GlRenderer.cpp (modified) (3 diffs)
• GlRenderer.h (modified) (2 diffs)
• GlobalLinesRenderer.cpp (modified) (27 diffs)
• GlobalLinesRenderer.h (modified) (3 diffs)
• IntelRayCaster.cpp (modified) (2 diffs)
• Preprocessor.cpp (modified) (2 diffs)
• VrmlExporter.cpp (modified) (3 diffs)

GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.cpp

@@ -251 +251 @@
 
 void
-GlRenderer::SetupFalseColor(const int id)
+GlRenderer::SetupFalseColor(const unsigned int id)
 {
         // swap bits of the color
@@ -258 +258 @@
 
 
-int GlRenderer::GetId(int r, int g, int b) const
+unsigned int GlRenderer::GetId(const unsigned char r, 
+                                                           const unsigned char g, 
+                                                           const unsigned char b) const
 {
         return r + (g << 8) + (b << 16);
 }
+
 
 void
@@ -269 +272 @@
         glColor3fv(&(m->mDiffuseColor.r));
 }
+
 
 void

GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.h

@@ -106 +106 @@
   virtual void RandomViewPoint();
 
-  void SetupFalseColor(const int id);
+  void SetupFalseColor(const unsigned int id);
   void RenderIntersectable(Intersectable *);
   void RenderViewCell(ViewCell *vc);
@@ -152 +152 @@
   virtual int GetHeight() const { return 0; }
 
-  int GetId(int r, int g, int b) const;
+  unsigned int GetId(const unsigned char r, 
+                                         const unsigned char g, 
+                                         const unsigned char b) const;
 
   inline const bool GetSnapErrorFrames() { return mSnapErrorFrames; }

GTP/trunk/Lib/Vis/Preprocessing/src/GlobalLinesRenderer.cpp

@@ -5 +5 @@
 #include "Preprocessor.h"
 #include "GlRenderer.h"
+#include "Exporter.h"
+
 // the devil library
 #include <IL/il.h>
@@ -27 +29 @@
 GlobalLinesRenderer *globalLinesRenderer = NULL;
 
-static int texWidth = 256;
-static int texHeight = 256;
-
+static int texWidth = 128;
+static int texHeight = 128;
+
+static bool isDepth = true;
 
 static void InitDevIl()
@@ -89 +92 @@
 
 
-void SetFrustum(int sizeX, int sizeY, float nearPlane, float farPlane)
+void SetFrustum(const int sizeX, const int sizeY, 
+                                const float nearPlane, const float farPlane)
 {
         glMatrixMode(GL_PROJECTION);
         glLoadIdentity();
 
-        glOrtho(-sizeX / 2, sizeX / 2, 
-                        -sizeY / 2, sizeY / 2, 
+        glOrtho(-sizeX * 0.5, sizeX * 0.5, 
+                        -sizeY * 0.5, sizeY * 0.5, 
                         nearPlane, farPlane);
 
@@ -107 +111 @@
         //globalLinesRenderer->DrawGeometry();
         //globalLinesRenderer->CastGlobalLines(Beam(), 0);
-        globalLinesRenderer->DisplayBuffer();
+        globalLinesRenderer->DisplayBuffer(isDepth);
         PrintGLerror("display");
 
@@ -132 +136 @@
 
                         cout << "max depth: " << globalLinesRenderer->mMaxDepth << endl;
+                        CLEAR_CONTAINER(rays);
                         return;
                 }
@@ -142 +147 @@
                         
                         globalLinesRenderer->ApplyDepthPeeling(rays, Beam(), 0);
+                        CLEAR_CONTAINER(rays);
                         return;
                 }
@@ -148 +154 @@
                         //globalLinesRenderer->ApplyDepthPeeling(Beam(), 0);
                         globalLinesRenderer->ExportDepthBuffer();
+                        
                         return;
                 }
         case '4':
                 {
+                        //globalLinesRenderer->ApplyDepthPeeling(Beam(), 0);
+                        globalLinesRenderer->ExportItemBuffer();
+                        
+                        return;
+                }
+        case '8':
+                {
+                        isDepth = !isDepth;
+                        return;
+                }
+        case '9':
+                {
                         VssRayContainer rays;
-
                         globalLinesRenderer->ApplyDepthPeeling(rays, Beam(), 0);
+                        VssRayContainer outRays;
+                        VssRayContainer::const_iterator vit, vit_end = rays.end();
+
+                        const float p = 8.0f / (float)rays.size();
+
+                        for (vit = rays.begin(); vit != vit_end; ++ vit)
+                        {
+                                if (Random(1.0f) < p)
+                                {
+                                        outRays.push_back(*vit);
+                                }
+                        }
+
+                        globalLinesRenderer->Visualize(rays);
+                        CLEAR_CONTAINER(rays);
+                        return;
+                }
+        case '0':
+                {
+                        VssRayContainer rays;
+                        globalLinesRenderer->ApplyDepthPeeling(rays, Beam(), 0);
+                        CLEAR_CONTAINER(rays);
                         return;
                 }
@@ -185 +225 @@
 
 
-void GlobalLinesRenderer::DisplayBuffer()
-{
-        //mNewTexture->Bind();
-        mNewTexture->BindDepth();
+void GlobalLinesRenderer::DisplayBuffer(const bool isDepth)
+{
+        if (!isDepth)
+                mNewTexture->Bind();
+        else
+                mNewTexture->BindDepth();
         mNewTexture->EnableTextureTarget();
         
@@ -262 +304 @@
                 for (oit = mPreprocessor->mObjects.begin(); oit != oit_end; ++ oit)
                 {
+                        cout << (*oit)->GetId() << " ";
                         RenderObject(*oit);
                 }
@@ -297 +340 @@
         InitDevIl();
 
-        glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
+    glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
         glutInitWindowPosition(50, 50);
         glutInitWindowSize(512, 512);
@@ -321 +364 @@
         // initialise the receiving buffers
         mNewDepthBuffer = new float[texWidth * texHeight];
+        mNewItemBuffer = new unsigned char[texWidth * texHeight * 4];
+
         mOldDepthBuffer = new float[texWidth * texHeight];
-        
+    mOldItemBuffer = new unsigned char[texWidth * texHeight * 4];
+
         for (int i = 0; i < texWidth * texHeight; ++ i)
         {
                 mNewDepthBuffer[i] = 1;
                 mOldDepthBuffer[i] = 1;
-        }
-
-        mNewItemBuffer = new int[texWidth * texHeight *4];
-        mOldItemBuffer = new int[texWidth * texHeight *4];
-        
-        for (int i = 0; i < texWidth * texHeight * 4; ++ i)
-        {
-                mNewItemBuffer[i] = 0;
-                mOldItemBuffer[i] = 0;
+
+                mNewItemBuffer[i * 4]     = 255;
+                mNewItemBuffer[i * 4 + 1] = 255;
+                mNewItemBuffer[i * 4 + 2] = 255;
+                mNewItemBuffer[i * 4 + 3] = 255;
+
+                mOldItemBuffer[i * 4]     = 255;
+                mOldItemBuffer[i * 4 + 1] = 255;
+                mOldItemBuffer[i * 4 + 2] = 255;
+                mOldItemBuffer[i * 4 + 3] = 255;
         }
 
         AxisAlignedBox3 bbox = globalLinesRenderer->mPreprocessor->mKdTree->GetBox();
         
-        mViewPoint = bbox.Center();
+        Vector3 midPoint = bbox.Center();
         
         const float sceneSize = Magnitude(bbox.Diagonal());
-        Vector3 viewPoint = mViewPoint + Vector3(0.5 * sceneSize, 0, 0);
-        
-        cout << "mid point: " << mViewPoint << endl;
-        cout << "view point: " << viewPoint << endl;
+        mViewPoint = midPoint + Vector3(0.5 * sceneSize, 0, 0);
+        
+        cout << "mid point: " << midPoint << endl;
+        cout << "view point: " << mViewPoint << endl;
         cout << "scene: " << bbox << endl;
 
-        mEyeVec = Normalize(viewPoint - mViewPoint);
+        mNear = 1;
+        mFar = sceneSize;
+        mWidth = sceneSize;
+
+        mEyeVec = Normalize(midPoint - mViewPoint);
         mEyeVec.RightHandedBase(mUpVec, mLeftVec);
 
-        /*gluLookAt(viewPoint.x, viewPoint.y, viewPoint.z, 
+        /*gluLookAt(mViewPoint.x, mViewPoint.y, mViewPoint.z, 
                           midPoint.x, midPoint.y, midPoint.z, 
                           0, 1, 0);
@@ -422 +473 @@
                 //Reshape(texWidth, texHeight);
                 glViewport(0, 0, texWidth, texHeight);
-                SetFrustum(sceneSize, sceneSize, 1, sceneSize);
+                SetFrustum(mWidth, mWidth, mNear, mFar);
 
                 // for item buffer: white means no color
@@ -430 +481 @@
                 glFrontFace(GL_CCW);
                 glCullFace(GL_BACK);
-                glEnable(GL_CULL_FACE);
+
+                glDisable(GL_CULL_FACE);
+                //glEnable(GL_CULL_FACE);
+
                 glShadeModel(GL_FLAT);
                 glEnable(GL_DEPTH_TEST);
@@ -436 +490 @@
                 glMatrixMode(GL_MODELVIEW);
                 glLoadIdentity();
-                gluLookAt(viewPoint.x, viewPoint.y, viewPoint.z, 
-                                  mViewPoint.x, mViewPoint.y, mViewPoint.z, 
+                gluLookAt(mViewPoint.x, mViewPoint.y, mViewPoint.z, 
+                                  midPoint.x, midPoint.y, midPoint.z, 
                                   0, 1, 0);
 
-                //SetFrustum(sceneSize, sceneSize, 1, sceneSize);
         }
         mNewTexture->EndCapture();
@@ -452 +505 @@
                 //Reshape(texWidth, texHeight);
                 glViewport(0, 0, texWidth, texHeight);
-                SetFrustum(sceneSize, sceneSize, 1, sceneSize);
+                SetFrustum(mWidth, mWidth, mNear, mFar);
 
                 glMatrixMode(GL_MODELVIEW);
@@ -459 +512 @@
                 glFrontFace(GL_CCW);
                 glCullFace(GL_BACK);
-                glEnable(GL_CULL_FACE);
+                
+                glDisable(GL_CULL_FACE);
+                //glEnable(GL_CULL_FACE);
+                
                 glShadeModel(GL_FLAT);
                 glEnable(GL_DEPTH_TEST);
                 
-                gluLookAt(viewPoint.x, viewPoint.y, viewPoint.z, 
-                                  mViewPoint.x, mViewPoint.y, mViewPoint.z, 
+                gluLookAt(mViewPoint.x, mViewPoint.y, mViewPoint.z, 
+                                  midPoint.x, midPoint.y, midPoint.z, 
                                   0, 1, 0);
 
@@ -475 +531 @@
 
 
-Intersectable *GetObject(const int index)
-{
-        return NULL;
-}
-
-
-void GlobalLinesRenderer::ProcessDepthBuffer(VssRayContainer &vssRays)
+Intersectable *GlobalLinesRenderer::ExtractSamplePoint(float *depthBuffer,
+                                                                                                           unsigned char *itemBuffer,
+                                                                                                           const int x, 
+                                                                                                           const int y,
+                                                                                                           Vector3 &hitPoint,
+                                                                                                           const bool isFrontBuffer) const
+{
+        const int depthIndex = x + texWidth * y;
+        const int itemIndex = 4 * depthIndex;
+
+        const float depth = depthBuffer[depthIndex];
+        const float eyeDist = mNear + (mFar - mNear) * depth;
+        
+        const float leftDist = 0.5f * mWidth - mWidth * ((float)x + 0.5f) / texWidth;
+        //const float upDist = 0.5f * mWidth - (float)mWidth * ((float)y + 0.5f) / texHeight;
+        const float upDist = -0.5f * mWidth + mWidth * ((float)y + 0.5f) / texHeight;
+        
+        hitPoint = mViewPoint + 
+                       eyeDist * mEyeVec + 
+                           leftDist * mUpVec + 
+                           upDist * mLeftVec;
+                                
+        unsigned char r = itemBuffer[itemIndex];
+        unsigned char g = itemBuffer[itemIndex + 1];
+        unsigned char b = itemBuffer[itemIndex + 2];
+                        
+        // 3 times 255 means no valid object
+        if ((r == 255) && (g == 255) && (b == 255))
+                return NULL;
+
+        const int id = mRenderer->GetId(r, g, b);
+        //cout << "r: " << (int)r << "g: " << (int)g << " b: " << (int)b << " id: " << id << "|";
+        Intersectable *intersect = mPreprocessor->GetObjectById(id);
+
+        const Vector3 dir = isFrontBuffer ? mEyeVec : -mEyeVec;
+        // HACK: assume triangle intersectable
+        const Vector3 norm = intersect->GetNormal(0); 
+
+        //if (DotProd(dir, norm) >= -Limits::Small) 
+                return intersect;
+}
+
+
+void GlobalLinesRenderer::ProcessDepthBuffer(VssRayContainer &vssRays, 
+                                                                                         const bool oldBufferInitialised)
 {
         GrabDepthBuffer(mNewDepthBuffer, mNewTexture);
-        GrabDepthBuffer(mOldDepthBuffer, mOldTexture);
-
         GrabItemBuffer(mNewItemBuffer, mNewTexture);
-        GrabItemBuffer(mOldItemBuffer, mOldTexture);
+
+        if (oldBufferInitialised)
+        {
+                GrabDepthBuffer(mOldDepthBuffer, mOldTexture);
+                GrabItemBuffer(mOldItemBuffer, mOldTexture);
+        }
+        else
+        {
+                for (int i = 0; i < texWidth * texHeight; ++ i)
+                {
+                        mOldDepthBuffer[i] = 0;
+
+                        mOldItemBuffer[i * 4]     = 255;
+                        mOldItemBuffer[i * 4 + 1] = 255;
+                        mOldItemBuffer[i * 4 + 2] = 255;
+                        mOldItemBuffer[i * 4 + 3] = 255;
+                }
+        }
+
+        cout << "vp: " << "eye: " << mEyeVec << " left: " << mLeftVec << " up: " << mUpVec << endl;
 
         for (int y = 0; y < texHeight; ++ y)
@@ -493 +604 @@
                 for (int x = 0; x < texWidth; ++ x)
                 {
-                        const int index = x + texWidth * y;
-                        const float newDepth = mNewDepthBuffer[index];
-                        const float oldDepth = mOldDepthBuffer[index];
-
-                        float newDummy1 = mNear + (mFar - mNear) * newDepth;
-                        float oldDummy1 = mNear + (mFar - mNear) * oldDepth;
-
-                        float newDummy2 = x - texWidth / 2;
-                        float newDummy3 = y - texHeight / 2;
-
-                        float oldDummy2 = newDummy2;
-                        float oldDummy3 = newDummy3;
-
-                        const Vector3 newPt = mViewPoint + newDepth * mEyeVec + newDummy1 * mLeftVec + newDummy2 * mUpVec;
-                        const Vector3 oldPt = mViewPoint + oldDepth * mEyeVec + oldDummy1 * mLeftVec + oldDummy2 * mUpVec;
-
-                        //cout << "viewpoint: " << mViewPoint << " new: " << newPt << " old: " << newPt << endl;
-                        
-                        int r = mNewItemBuffer[index];
-                        int g = mNewItemBuffer[index + 1];
-                        int b = mNewItemBuffer[index + 2];
-                        
-                        Intersectable *termObj1 = NULL;
-                        Intersectable *termObj2 = NULL;
-
-                        // 3 times 255 means no valid object
-                        if (!((r == 255) && (g == 255) && (b == 255)))
+                        Vector3 newPt, oldPt;
+
+                        Intersectable *termObj1 = ExtractSamplePoint(mNewDepthBuffer, 
+                                                                                                                 mNewItemBuffer, 
+                                                                                                                 x, 
+                                                                                                                 y, 
+                                                                                                                 newPt, 
+                                                                                                                 true);
+
+                        Intersectable *termObj2 = ExtractSamplePoint(mOldDepthBuffer, 
+                                                                                                                 mOldItemBuffer, 
+                                                                                                                 x, 
+                                                                                                                 y, 
+                                                                                                                 oldPt, 
+                                                                                                                 false);
+
+                        // create rays in both directions
+                        if (termObj1)
                         {
-                                const int id = mRenderer->GetId(r, g, b);
-                                cout << id << " ";
-                                //termObj1 = mPreprocessor->GetObjectById(id);
+                                vssRays.push_back(new VssRay(oldPt, newPt, NULL, termObj1));
+                                //cout << "new pt: " << newPt << endl;
                         }
 
-                        /*r = mOldItemBuffer[index];
-                        g = mOldItemBuffer[index + 1];
-                        b = mOldItemBuffer[index + 2];
-
-                        if (!((r == 255) && (g == 255) && (b == 255)))
-                                Intersectable *termObj2 = mPreprocessor->GetObjectById(mRenderer->GetId(r, g, b));
-*/
-                        // create rays in both directions
-                        //vssRays.push_back(new VssRay(oldPt, newPt, NULL, termObj1));
-                        //vssRays.push_back(new VssRay(newPt, oldPt, NULL, termObj2));
+                        //if (termObj2)
+                        //{
+                        //      vssRays.push_back(new VssRay(oldPt, newPt, NULL, termObj2));
+                        //      cout << "old pt: " << oldPt << endl;
+                        //}
                 }
         }
@@ -544 +640 @@
 {
         glutMainLoop();
+}
+
+
+void SetupFalseColor(const unsigned int id, 
+                                         unsigned char &r,
+                                         unsigned char &g,
+                                         unsigned char &b
+                                         )
+{
+        // swap bits of the color
+        r = id & 255;
+        g = (id >> 8) & 255;
+        b = (id >> 16) & 255;
+}
+
+
+void GlobalLinesRenderer::Visualize(const VssRayContainer &vssRays)
+{
+        Exporter *exporter = Exporter::GetExporter("globalLines.wrl");
+        
+        if (!exporter)
+                return;
+
+        exporter->SetWireframe();
+        //exporter->ExportGeometry(preprocessor->mObjects);
+        exporter->SetFilled();
+
+        VssRayContainer::const_iterator vit, vit_end = vssRays.end();
+
+        for (vit = vssRays.begin(); vit != vit_end; ++ vit)
+        {
+                VssRay *ray = *vit;
+                Intersectable *obj = (*vit)->mTerminationObject;        
+                exporter->ExportIntersectable(obj);
+                
+                unsigned char r, g, b;
+                SetupFalseColor(obj->GetId(), r, g, b);
+                int id = mRenderer->GetId(r, g, b);
+
+                if (id != obj->GetId())
+                        cout << "error!" << endl;
+                else cout <<"x";
+        }       
+
+        exporter->ExportRays(vssRays);
+
+        delete exporter;
 }
 
@@ -560 +703 @@
 
 
-void GlobalLinesRenderer::GrabItemBuffer(int *data, RenderTexture *rt)
+void GlobalLinesRenderer::GrabItemBuffer(unsigned char *data, RenderTexture *rt)
 {
         rt->Bind();
@@ -567 +710 @@
 
         const int texFormat = GL_RGBA;
-        glGetTexImage(mNewTexture->GetTextureTarget(), 0, texFormat, GL_FLOAT, data);
+        glGetTexImage(mNewTexture->GetTextureTarget(), 0, texFormat, GL_UNSIGNED_BYTE, data);
 
         mNewTexture->DisableTextureTarget();
@@ -579 +722 @@
         cout << "depth: " << mNewTexture->GetDepthBits() << endl;
 
-        const bool components = 1;//mNewTexture->GetDepthBits() / 8;
+        const int components = 1;//mNewTexture->GetDepthBits() / 8;
 
         float *data = new float[texWidth * texHeight * components];
@@ -609 +752 @@
 }
 
-
 /*
 void GlobalLinesRenderer::ExportItemBuffer()
 {
-        mNewTexture->BindDepth();
+        mNewTexture->Bind();
         mNewTexture->EnableTextureTarget();
         cout << "depth: " << mNewTexture->GetDepthBits() << endl;
 
-        const bool components = 1;//mNewTexture->GetDepthBits() / 8;
-
-        float *data = new float[texWidth * texHeight * components];
-        //const int texFormat = WGL_TEXTURE_DEPTH_COMPONENT_NV;
-        const int texFormat = GL_DEPTH_COMPONENT;
-        //const int texFormat = GL_RGBA;
+        const int components = 4;//mNewTexture->GetDepthBits() / 8;
+
+        float *data = new float[texWidth * texHeight * components*8];
+        const int texFormat = GL_RGBA;
         glGetTexImage(mNewTexture->GetTextureTarget(), 0, texFormat, GL_FLOAT, data);
 
-        string filename("depth.tga");
+        string filename("items.tga");
         ilRegisterType(IL_FLOAT);
 
@@ -631 +771 @@
         const int bpp = components;
 
-        ilTexImage(texWidth, texHeight, depth, bpp, IL_LUMINANCE, IL_FLOAT, data);
+        cout << "saving items to file " << endl;
+
+        ilTexImage(16, 16, depth, bpp, IL_RGBA, IL_FLOAT, data);
         ilSaveImage((char *const)filename.c_str());
 
@@ -641 +783 @@
 }
 */
+void GlobalLinesRenderer::ExportItemBuffer()
+{
+        mNewTexture->Bind();
+        mNewTexture->EnableTextureTarget();
+        cout << "depth: " << mNewTexture->GetDepthBits() << endl;
+
+        const int components = 4;//mNewTexture->GetDepthBits() / 8;
+
+        unsigned char *data = new unsigned char [texWidth * texHeight * components];
+        //const int texFormat = WGL_TEXTURE_DEPTH_COMPONENT_NV;
+        const int texFormat = GL_RGBA;
+        glGetTexImage(mNewTexture->GetTextureTarget(), 0, texFormat, GL_UNSIGNED_BYTE, data);
+
+        string filename("items.jpg");
+        ilRegisterType(IL_UNSIGNED_BYTE);
+
+        const int depth = 1;
+        const int bpp = components;
+
+        ilTexImage(texWidth, texHeight, depth, bpp, IL_RGBA, IL_UNSIGNED_BYTE, data);
+        ilSaveImage((char *const)filename.c_str());
+
+        cout << "finished" << endl;
+        delete data;
+        cout << "data deleted" << endl;
+        mNewTexture->DisableTextureTarget();
+        PrintGLerror("grab texture");
+}
 
 
@@ -659 +829 @@
 
         // process the buffers for the first layer
-        ProcessDepthBuffer(rays);
+        ProcessDepthBuffer(rays, false);
 
         for(int i = 0; i < mMaxDepth; ++ i) 
@@ -685 +855 @@
                         cgGLDisableTextureParameter(sTextureParam);
                         cgGLDisableProfile(sCgFragmentProfile);
-
-                        // process the buffers for following layer
-                        ProcessDepthBuffer(rays);
-
                 }
                 mNewTexture->EndCapture();
+
+                // process the buffers for following layer
+                ProcessDepthBuffer(rays, true);
         }
 

GTP/trunk/Lib/Vis/Preprocessing/src/GlobalLinesRenderer.h

@@ -48 +48 @@
         */
         void DrawGeometry();
-void Run();
-void GrabDepthBuffer(float *data, RenderTexture *rt);
-void GrabItemBuffer(int *data, RenderTexture *rt);
-void ApplyDepthPeeling(VssRayContainer &rays, Beam &beam, const int samples);
-void ExportDepthBuffer();
-void ProcessDepthBuffer(VssRayContainer &vssRays);
-void DisplayBuffer();
+        void Run();
+        void GrabDepthBuffer(float *data, RenderTexture *rt);
+        void GrabItemBuffer(unsigned char *data, RenderTexture *rt);
+        void ApplyDepthPeeling(VssRayContainer &rays, Beam &beam, const int samples);
+        void ExportDepthBuffer();
+        void ExportItemBuffer();
+        void ProcessDepthBuffer(VssRayContainer &vssRays, const bool oldBufferInitialised);
+        void DisplayBuffer(const bool isDepth);
+        
+        Intersectable *ExtractSamplePoint(float *depthBuffer,
+                                                                          unsigned char *itemBuffer,
+                                                                          const int x, 
+                                                                          const int y,
+                                                                          Vector3 &hitPoint,
+                                                                          const bool isFrontBuffer) const;
+
+        void Visualize(const VssRayContainer &vssRays);
 
         int mMaxDepth;
@@ -62 +72 @@
         float mFar;
         float mNear;
+        float mWidth;
 
         Vector3 mViewPoint;
@@ -67 +78 @@
         float *mNewDepthBuffer;
         float *mOldDepthBuffer;
-        int *mNewItemBuffer;
-        int *mOldItemBuffer;
-RenderTexture *mNewTexture;
+        unsigned char *mNewItemBuffer;
+        unsigned char *mOldItemBuffer;
+        
+        RenderTexture *mNewTexture;
         RenderTexture *mOldTexture;
 

GTP/trunk/Lib/Vis/Preprocessing/src/IntelRayCaster.cpp

@@ -13 +13 @@
 
 
-IntelRayCaster::IntelRayCaster(const Preprocessor &preprocessor, const string externKdTree):
+IntelRayCaster::IntelRayCaster(const Preprocessor &preprocessor, 
+                                                           const string externKdTree):
 RayCaster(preprocessor)
 {
@@ -74 +75 @@
                 Vector3 dir = -simpleRay.mDirection;
                 hittriangle = mlrtaIntersectAS(
-                        &simpleRay.mOrigin.x,
-                        &dir.x,
-                        normal,
-                        dist);
+                                                                                &simpleRay.mOrigin.x,
+                                                                                &dir.x,
+                                                                                normal,
+                                                                                dist);
 
                 Intersectable *intersect = mPreprocessor.GetParentObject(hittriangle);

GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.cpp

@@ -1297 +1297 @@
 Intersectable *Preprocessor::GetObjectById(const int id)
 {
-#if 0
+#if 1
         // create a dummy mesh instance to be able to use stl
         MeshInstance object(NULL);
@@ -1315 +1315 @@
         }
 #else
-        return mObjects[id];
+        return mObjects[id - 1];
 #endif
 }

GTP/trunk/Lib/Vis/Preprocessing/src/VrmlExporter.cpp

@@ -124 +124 @@
         {
                 const Vector3 a = (*ri)->GetOrigin();
-                const Vector3 b = (*ri)->mTerminationObject ? (*ri)->GetTermination() : a + 1000 * Normalize((*ri)->GetDir());
+                const Vector3 b = (*ri)->mTerminationObject ? 
+                        (*ri)->GetTermination() : a + 1000 * Normalize((*ri)->GetDir());
 
 #if GTP_DEBUG
@@ -130 +131 @@
                 if (!a.CheckValidity())
                 {
-                        cout << "error a"<<endl;
+                        cout << "error a" << endl;
                         isnan = true;
                 }
@@ -136 +137 @@
                 if (!b.CheckValidity())
                 {
-                        cout << "error b"<<endl;
+                        cout << "error b" << endl;
                         isnan = true;
                 }