Changeset 1968 for GTP

Timestamp:

01/11/07 04:18:36 (18 years ago)

Author:

mattausch

Message:

early exit for global lines
preprocessor support

Location:

GTP/trunk/Lib/Vis/Preprocessing/src

Files:

• Environment.cpp (modified) (4 diffs)
• GlRenderer.h (modified) (2 diffs)
• GlobalLinesRenderer.cpp (modified) (10 diffs)
• GlobalLinesRenderer.h (modified) (9 diffs)
• Preprocessor.cpp (modified) (12 diffs)
• Preprocessor.h (modified) (4 diffs)
• Preprocessor.vcproj (modified) (1 diff)
• SamplingStrategy.cpp (modified) (3 diffs)
• SamplingStrategy.h (modified) (2 diffs)
• main.cpp (modified) (1 diff)

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

@@ -1188 +1188 @@
                                  "1000000");
 
+  RegisterOption("Preprocessor.useHwGlobalLines",
+                                 optBool,
+                                 "preprocessor_use_hw_global_lines=",
+                                 "false");
+
+   RegisterOption("Preprocessor.HwGlobalLines.texHeight",
+                                  optInt,
+                                  "preprocessor_hw_global_lines_texheight=",
+                                  "128");
+
+    RegisterOption("Preprocessor.HwGlobalLines.texWidth",
+                                   optInt,
+                                   "preprocessor_hw_global_lines_texwidth=",
+                                   "128");
+
+        RegisterOption("Preprocessor.HwGlobalLines.stepSize",
+                                   optFloat,
+                                   "preprocessor_hw_global_lines_stepsize=",
+                                   "0.0001");
+
+        RegisterOption("Preprocessor.HwGlobalLines.maxDepth",
+                                   optInt,
+                                   "preprocessor_hw_global_lines_max_depth=",
+                                   "50");
+
+        RegisterOption("Preprocessor.HwGlobalLines.sampleReverse",
+                                   optBool,
+                                   "preprocessor_hw_global_lines_sample_reverse=",
+                                   "true");
+
   RegisterOption("RenderSampler.samples",
                                  optInt,
@@ -1198 +1228 @@
                                  "0");
 
-
    RegisterOption("RenderSampler.useOcclusionQueries",
                                  optBool,
@@ -1252 +1281 @@
 
 
-   /************************************************************************************/
-   /*                         GvsPrerpocessor related options                          */
-   /************************************************************************************/
+   /*************************************************************************/
+   /*                       GvsPrerpocessor related options                 */
+   /*************************************************************************/
 
 
@@ -1287 +1316 @@
                                         "gvsStats.log");
 
-  /***********************************************************************************/
-  /*                         View cells related options                              */
-  /***********************************************************************************/
+        
+  /**********************************************************************/
+  /*                     View cells related options                     */
+  /**********************************************************************/
 
 

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

@@ -224 +224 @@
 public:
 
-GlRendererBuffer(SceneGraph *sceneGraph,
-                                 ViewCellsManager *viewcells,
-                                 KdTree *tree);
-
-  virtual ~GlRendererBuffer();
+        GlRendererBuffer(SceneGraph *sceneGraph,
+                ViewCellsManager *viewcells,
+                KdTree *tree);
+
+        virtual ~GlRendererBuffer();
 
         /** Evaluates render cost of a point sample.
-                @param sample the render cost sample to be evaluated
-                @param useOcclusionQueries if occlusion queries should be used or item buffer
-                @param threshold number of pixels / samples from where an object is considered visible.
-        */
-  virtual void EvalRenderCostSample(RenderCostSample &sample,
-                                                          const bool useOcclusionQueries,
-                                                          const int threshold);
+        @param sample the render cost sample to be evaluated
+        @param useOcclusionQueries if occlusion queries should be used or item buffer
+        @param threshold number of pixels / samples from where an object is considered visible.
+        */
+        virtual void EvalRenderCostSample(RenderCostSample &sample,
+                const bool useOcclusionQueries,
+                const int threshold);
 
         /** Evaluates render cost of a number of point samples. The point samples
-                are distributed uniformly over the defined view space.
-
-                @param numSamples the number of point samples taken
-                @param samples stores the taken point samples in a container
-                @param useOcclusionQueries if occlusion queries should be used or item buffer
-                @param threshold number of pixels / samples from where an object is considered visible.
-        */
-  virtual void SampleRenderCost(const int numSamples, 
-                                                                vector<RenderCostSample> &samples,
-                                                                const bool useOcclusionQueries,
-                                                                const int threshold = 0);
-  
+        are distributed uniformly over the defined view space.
+
+        @param numSamples the number of point samples taken
+        @param samples stores the taken point samples in a container
+        @param useOcclusionQueries if occlusion queries should be used or item buffer
+        @param threshold number of pixels / samples from where an object is considered visible.
+        */
+        virtual void SampleRenderCost(const int numSamples, 
+                vector<RenderCostSample> &samples,
+                const bool useOcclusionQueries,
+                const int threshold = 0);
+
 
         /** Implerment in subclasses.
         */
-  virtual void EvalPvsStat();
-
-
-  virtual int GetWidth() const = 0;
-  virtual int GetHeight() const  = 0; 
-
-  virtual void MakeCurrent() = 0;
-  virtual void DoneCurrent() = 0;
-  
-
-  virtual void SampleBeamContributions(
-                                                           Intersectable *sourceObject,
-                                                           Beam &beam,
-                                                           const int samples,
-                                                           BeamSampleStatistics &stat
-                                                           );
-
-  virtual void
-  SampleViewpointContributions(
-                                                           Intersectable *sourceObject,
-                                                           const Vector3 viewPoint,
-                                                           Beam &beam,
-                                                           const int desiredSamples,
-                                                           BeamSampleStatistics &stat
-                                                           );
-
-  virtual void InitGL();
-
-  /** Computes rays from information gained with hw sampling-
-  */
-  virtual void ComputeRays(Intersectable *sourceObj, VssRayContainer &rays);
-
-  virtual int ComputePvs() const = 0;
-
-  
-  virtual int ComputePvs(ObjectContainer &objects, ObjectContainer &pvs) const = 0;
-
-
-
-  
+        virtual void EvalPvsStat();
+
+
+        virtual int GetWidth() const = 0;
+        virtual int GetHeight() const  = 0; 
+
+        virtual void MakeCurrent() = 0;
+        virtual void DoneCurrent() = 0;
+
+
+        virtual void SampleBeamContributions(
+                Intersectable *sourceObject,
+                Beam &beam,
+                const int samples,
+                BeamSampleStatistics &stat
+                );
+
+        virtual void
+                SampleViewpointContributions(
+                Intersectable *sourceObject,
+                const Vector3 viewPoint,
+                Beam &beam,
+                const int desiredSamples,
+                BeamSampleStatistics &stat
+                );
+
+        virtual void InitGL();
+
+        /** Computes rays from information gained with hw sampling-
+        */
+        virtual void ComputeRays(Intersectable *sourceObj, VssRayContainer &rays);
+
+        virtual int ComputePvs() const = 0;
+
+        virtual int ComputePvs(ObjectContainer &objects, ObjectContainer &pvs) const = 0;
+
+
 protected:
-  unsigned int *mPixelBuffer;
-  
-  static void GenQueries(const int numQueries);
-        
-  virtual void SetupProjectionForViewPoint(const Vector3 &viewPoint, 
-                                                                         const Beam &beam, 
-
-                                                                         Intersectable *sourceObject);
+
+        unsigned int *mPixelBuffer;
+
+        static void GenQueries(const int numQueries);
+
+        virtual void SetupProjectionForViewPoint(const Vector3 &viewPoint, 
+                const Beam &beam, 
+
+                Intersectable *sourceObject);
 
         /** Evaluates query for one direction using item buffer.
         */
-  virtual void EvalQueryWithItemBuffer();
+        virtual void EvalQueryWithItemBuffer();
 
         /** Evaluates query for one direction using occlusion queries.
         */
-  virtual void EvalQueryWithOcclusionQueries();
+        virtual void EvalQueryWithOcclusionQueries();
 
 public:
         // matt: remove qt dependencies
- // signals:
-//      void UpdatePvsErrorItem(int i, GlRendererBuffer::PvsErrorEntry &);
+        // signals:
+        //      void UpdatePvsErrorItem(int i, GlRendererBuffer::PvsErrorEntry &);
 };
 
@@ -325 +323 @@
 {
 public:
-        
+
         GlRendererWidget(SceneGraph *sceneGraph, ViewCellsManager *vcm, KdTree *kdTree):
           GlRenderer(sceneGraph, vcm, kdTree)
-        {}
-
-    GlRendererWidget() {}
-
-    virtual ~GlRendererWidget() {}
-
-        //virtual void Create() {}
-        virtual void Show() {}
-        
+          {}
+
+          GlRendererWidget() {}
+
+          virtual ~GlRendererWidget() {}
+
+          //virtual void Create() {}
+          virtual void Show() {}
+
 
 protected:
 
 
-  //    SceneGraph *mSceneGraph;
-  //    ViewCellsManager *mViewCellsManager;
-  //    KdTree *mKdTree;
+        //      SceneGraph *mSceneGraph;
+        //      ViewCellsManager *mViewCellsManager;
+        //      KdTree *mKdTree;
 };
 

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

@@ -200 +200 @@
 
 
-/*GlobalLinesRenderer::GlobalLinesRenderer(RenderTexture *buffer1, 
-                                                                                 RenderTexture *buffer2, 
-                                                                                 Preprocessor *preprocessor,
-                                                                                 GlRenderer *renderer)
-: mNewTexture(buffer1), mOldTexture(buffer2), mPreprocessor(preprocessor), mMaxDepth(100),
-mRenderer(renderer)
-{
-}
-*/
-
-
 GlobalLinesRenderer::GlobalLinesRenderer(Preprocessor *preprocessor, 
-                                                                                 GlRenderer *renderer,
-                                                                                 const float mTexHeight,
-                                                                                 const float mTexWidth,
-                                                                                 const float eps): 
+                                                                                 const int texHeight,
+                                                                                 const int texWidth,
+                                                                                 const float eps,
+                                                                                 const int maxDepth,
+                                                                                 const bool sampleReverse):
 mNewTexture(NULL), 
 mOldTexture(NULL), 
-mMaxDepth(0), 
-mRenderer(renderer), 
 mPreprocessor(preprocessor),
 mTexHeight(mTexHeight),
 mTexWidth(mTexWidth),
-mEpsilon(eps)
-{
-}
-
-
-GlobalLinesRenderer::GlobalLinesRenderer(Preprocessor *preprocessor, 
-                                                                                 GlRenderer *renderer):
+mEpsilon(eps),
+mMaxDepth(maxDepth),
+mSampleReverse(sampleReverse)
+{
+        mRenderer = new GlRenderer(mPreprocessor->mSceneGraph,
+                                                           mPreprocessor->mViewCellsManager,
+                                                           mPreprocessor->mKdTree);
+
+}
+
+
+GlobalLinesRenderer::GlobalLinesRenderer(Preprocessor *preprocessor):
 mNewTexture(NULL), 
 mOldTexture(NULL), 
-mMaxDepth(0), 
-mRenderer(renderer), 
+mMaxDepth(40), 
 mPreprocessor(preprocessor),
 mTexHeight(128),
 mTexWidth(128),
-mEpsilon(0.0001)
-{}
+mEpsilon(0.0001),
+mSampleReverse(true)
+{
+        mRenderer = new GlRenderer(mPreprocessor->mSceneGraph,
+                                                           mPreprocessor->mViewCellsManager,
+                                                           mPreprocessor->mKdTree);
+}
 
 
@@ -288 +285 @@
         delete mNewItemBuffer;
         delete mOldItemBuffer;
+
+        DEL_PTR(mRenderer);
 }
 
  
-void GlobalLinesRenderer::InitScene(const float alpha, const float beta)
-{
-        AxisAlignedBox3 bbox = globalLinesRenderer->mPreprocessor->mKdTree->GetBox();
-        
-        const float sceneSize = Magnitude(bbox.Diagonal());
-
-        // compute the center of the scene
-        Vector3 midPoint = bbox.Center();
-        
-        // add a small offset to provide some randomness in the sampling
-        Vector3 offset(Random(sceneSize * 1e-3f), 
-                                   Random(sceneSize * 1e-3f), 
-                                   Random(sceneSize * 1e-3f));
-
-        midPoint += offset;
-                
-        mNear = 1;
-        mFar = sceneSize * 2;
-        mWidth = sceneSize;
-
-        ComputeLookAt(alpha, 
-                                  beta,
-                                  mEyeVec, 
-                                  mUpVec,
-                                  mLeftVec);
-        
-        mViewPoint = midPoint - 0.5f * sceneSize * mEyeVec;
-
-        cout << "mid point: " << midPoint << endl;
-        cout << "view point: " << mViewPoint << endl;
-        cout << "scene: " << bbox << endl;
-
+void GlobalLinesRenderer::InitRenderTexture(RenderTexture *rt)
+{
          // setup the rendering context for the RenderTexture
-        mNewTexture->BeginCapture();
+        rt->BeginCapture();
         {
                 //Reshape(mTexWidth, mTexHeight);
@@ -346 +315 @@
                 glLoadIdentity();
                 gluLookAt(mViewPoint.x, mViewPoint.y, mViewPoint.z, 
-                                  midPoint.x, midPoint.y, midPoint.z, 
+                                  mTermination.x, mTermination.y, mTermination.z, 
                                   mUpVec.x, mUpVec.y, mUpVec.z);
 
         }
-        mNewTexture->EndCapture();
-
-        // setup the rendering context for the other depth buffer
-        mOldTexture->BeginCapture();
-        {
-                // for item buffer: white means no color
-                glClearColor(1, 1, 1, 1);
-       
-                //Reshape(mTexWidth, mTexHeight);
-                glViewport(0, 0, mTexWidth, mTexHeight);
-                SetFrustum(mWidth, mWidth, mNear, mFar);
-
-                glMatrixMode(GL_MODELVIEW);
-                glLoadIdentity();
+        rt->EndCapture();
+}
+
+
+void GlobalLinesRenderer::InitScene(const float alpha, const float beta)
+{
+        AxisAlignedBox3 bbox = 
+                globalLinesRenderer->mPreprocessor->mKdTree->GetBox();
+        
+        const float sceneSize = Magnitude(bbox.Diagonal());
+
+        // compute the center of the scene
+        mTermination = bbox.Center();
+        
+        // add a small offset to provide some randomness in the sampling
+        if (0)
+        {
+                Vector3 offset(
+                        Random(sceneSize * 1e-3f), 
+                        Random(sceneSize * 1e-3f), 
+                        Random(sceneSize * 1e-3f));
+
+                mTermination += offset;
+        }
                 
-                glFrontFace(GL_CCW);
-                glCullFace(GL_BACK);
-                
-                glDisable(GL_CULL_FACE);
-                //glEnable(GL_CULL_FACE);
-                
-                glShadeModel(GL_FLAT);
-                glEnable(GL_DEPTH_TEST);
-                
-                gluLookAt(mViewPoint.x, mViewPoint.y, mViewPoint.z, 
-                                  midPoint.x, midPoint.y, midPoint.z, 
-                                  mUpVec.x, mUpVec.y, mUpVec.z);
-        }
-        mOldTexture->EndCapture();
-
+        mNear = 1;
+        mFar = sceneSize * 2;
+        mWidth = sceneSize;
+
+        ComputeLookAt(alpha, 
+                                  beta,
+                                  mEyeVec, 
+                                  mUpVec,
+                                  mLeftVec);
+        
+        mViewPoint = mTermination - 0.5f * sceneSize * mEyeVec;
+
+        cout << "termination point: " << mTermination << endl;
+        cout << "view point: " << mViewPoint << endl;
+        cout << "scene: " << bbox << endl;
+
+        InitRenderTexture(mNewTexture);
+        InitRenderTexture(mOldTexture);
+        
+        cout << "eye: " << mEyeVec << " left: " << mLeftVec << " up: " << mUpVec << endl;
+}
+
+
+void GlobalLinesRenderer::InitScene(const SimpleRay &ray)
+{
+        AxisAlignedBox3 bbox = 
+                globalLinesRenderer->mPreprocessor->mKdTree->GetBox();
+        
+        const float sceneSize = Magnitude(bbox.Diagonal());
+
+        // compute the center of the scene
+        mViewPoint = ray.mOrigin;
+        mTermination = ray.mOrigin + ray.mDirection;
+
+        mEyeVec = Normalize(ray.mDirection);
+
+        mNear = 1;
+        mFar = sceneSize * 2;
+        mWidth = sceneSize;
+
+        mEyeVec.RightHandedBase(mUpVec, mLeftVec);
+    mViewPoint = mTermination - 0.5f * sceneSize * mEyeVec;
+
+        cout << "termination point: " << mTermination << endl;
+        cout << "view point: " << mViewPoint << endl;
+        cout << "scene: " << bbox << endl;
+
+        InitRenderTexture(mNewTexture);
+        InitRenderTexture(mOldTexture);
+        
         cout << "eye: " << mEyeVec << " left: " << mLeftVec << " up: " << mUpVec << endl;
 }
@@ -395 +409 @@
 }
 
+
+void GlobalLinesRenderer::CastGlobalLines(const SimpleRay &ray, 
+                                                                                  VssRayContainer &rays)
+{
+        InitScene(ray);
+
+        // bind pixel shader implementing the front depth buffer functionality
+        ApplyDepthPeeling(rays);
+}
 
 void GlobalLinesRenderer::RenderObject(Intersectable *obj)
@@ -438 +461 @@
                                                                                 Vector3 &left)
 {
-        //float x = cos(alpha);
-        //float y = sin(alpha);
         eye.x = sin(alpha) * cos(beta);
         eye.y = sin(alpha) * sin(beta);
         eye.z = cos(alpha);
 
-        //eye = Normalize(eye);
         eye.RightHandedBase(up, left);
 }
@@ -637 +657 @@
 
 
-void GlobalLinesRenderer::ProcessDepthBuffer(VssRayContainer &vssRays, 
+bool GlobalLinesRenderer::ProcessDepthBuffer(VssRayContainer &vssRays, 
                                                                                          const bool oldBufferInitialised,
                                                                                          const int pass)
@@ -660 +680 @@
                         mOldItemBuffer[i * 4 + 3] = 255;
                 }
+        }
+
+        /////////////////
+        // test for validity
+
+        bool buffersEqual = true;
+        bool bufferEmpty = true;
+
+        for (int y = 0; y < mTexHeight; ++ y)
+        {
+                for (int x = 0; x < mTexWidth; ++ x)
+                {
+                        const int depthIndex = x + mTexWidth * y;   
+                        const int itemIndex = 4 * depthIndex;
+                
+                        if (mOldItemBuffer[itemIndex] != mNewItemBuffer[itemIndex])
+                        {
+                                buffersEqual = false;
+                        }
+
+                        unsigned char r = mNewItemBuffer[itemIndex];
+                        unsigned char g = mNewItemBuffer[itemIndex + 1];
+                        unsigned char b = mNewItemBuffer[itemIndex + 2];
+
+                        // 3 times 255 means no valid object
+                        if (!((r == 255) && (g == 255) && (b == 255)))
+                        {
+                                bufferEmpty = false;
+                        }
+                }
+                
+                // early exit
+                if (!buffersEqual && !bufferEmpty)
+                        break;
+        }
+
+        // depth buffer not valid
+        if (buffersEqual || bufferEmpty)
+        {
+                cout << "stopped at layer " << pass << endl;
+                return false;
         }
 
@@ -698 +759 @@
                         }
 
-                        if (termObj2)
+                        if (mSampleReverse && termObj2)
                         {
                                 vssRays.push_back(new VssRay(clippedNewPt, clippedOldPt, NULL, termObj2, pass));
@@ -705 +766 @@
                 }
         }
+
+        return true;
 }
 
@@ -912 +975 @@
 
                 // process the buffers for following layer
-                ProcessDepthBuffer(rays, true, i);
+                // jump out of loop for the first invalid buffer
+                if (!ProcessDepthBuffer(rays, true, i))
+                        break;
         }
 

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

@@ -15 +15 @@
 class Preprocessor;
 class GlRenderer;
+struct SimpleRay;
 
 struct VssRayContainer;
@@ -23 +24 @@
         
         GlobalLinesRenderer(Preprocessor *preprocessor, 
-                                                GlRenderer *renderer,
-                                                const float texHeight,
-                                                const float mTexWidth,
-                                                const float eps);
+                                                const int texHeight,
+                                                const int mTexWidth,
+                                                const float eps,
+                                                const int maxDepth,
+                                                const bool sampleReverse);
 
-        GlobalLinesRenderer(Preprocessor *preprocessor, GlRenderer *renderer);
+        GlobalLinesRenderer(Preprocessor *preprocessor);
 
         ~GlobalLinesRenderer();
@@ -39 +41 @@
                                                  const float beta, 
                                                  VssRayContainer &rays);
+
+        /** Casts global lines using the given ray as origin and 
+                direction vector.
+                @returns Computed samples in the container rays
+        */
+        void CastGlobalLines(const SimpleRay &ray, 
+                                                 VssRayContainer &rays);
+
 
         void InitGl();
@@ -62 +72 @@
         void ExportDepthBuffer();
         void ExportItemBuffer();
-        void ProcessDepthBuffer(VssRayContainer &vssRays, 
+        bool ProcessDepthBuffer(VssRayContainer &vssRays, 
                                                         const bool oldBufferInitialised, 
                                                         const int pass);
@@ -83 +93 @@
 
         int mMaxDepth;
+        
         Vector3 mEyeVec;
         Vector3 mLeftVec;
         Vector3 mUpVec;
+        Vector3 mTermination;
+
         float mFar;
         float mNear;
@@ -94 +107 @@
         float *mNewDepthBuffer;
         float *mOldDepthBuffer;
+
         unsigned char *mNewItemBuffer;
         unsigned char *mOldItemBuffer;
@@ -105 +119 @@
                                            Vector3 &up, 
                                            Vector3 &left);
+
 protected:
 
@@ -110 +125 @@
 
         void InitScene(const float alpha, const float beta);
+        void InitScene(const SimpleRay &ray);
+
+        void InitRenderTexture(RenderTexture *rt);
 
         Preprocessor *mPreprocessor;
@@ -118 +136 @@
         int mTexHeight;
         float mEpsilon;
+
+        bool mSampleReverse;
 };
 

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

@@ -21 +21 @@
 #include "IntelRayCaster.h"
 #include "InternalRayCaster.h"
-
+#include "GlobalLinesRenderer.h"
 
 
@@ -134 +134 @@
 mRayCaster(NULL),
 mStopComputation(false),
-mThread(NULL)
+mThread(NULL),
+mGlobalLinesRenderer(NULL)
 {
         Environment::GetSingleton()->GetBoolValue("Preprocessor.useGlRenderer", mUseGlRenderer);
@@ -174 +175 @@
                                                                                          mSamplesPerEvaluation);
 
-        
         Debug << "******* Preprocessor Options **********" << endl;
         Debug << "detect empty view space=" << mDetectEmptyViewSpace << endl;
@@ -211 +211 @@
         DEL_PTR(renderer);
         DEL_PTR(mRayCaster);
+
+        DEL_PTR(mGlobalLinesRenderer);
 }
 
@@ -1074 +1076 @@
 
 
-bool Preprocessor::InitRayCast(const string externKdTree, const string internKdTree)
+bool Preprocessor::InitRayCast(const string externKdTree, 
+                                                           const string internKdTree)
 {
         // always try to load the kd tree
@@ -1081 +1084 @@
         if (!LoadKdTree(internKdTree))
         {
-                cout << "error loading kd tree with filename " << internKdTree << ", rebuilding it instead ... " << endl;
+                cout << "error loading kd tree with filename " 
+                         << internKdTree << ", rebuilding it instead ... " << endl;
                 // build new kd tree from scene geometry
                 BuildKdTree();
@@ -1091 +1095 @@
                 if (!ExportKdTree(internKdTree))
                 {
-                        cout << " error exporting kd tree with filename " << internKdTree << endl;
+                        cout << " error exporting kd tree with filename " 
+                                 << internKdTree << endl;
                 }
                 else
                 {
-                        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+                        cout << "finished in " 
+                                 << TimeDiff(startTime, GetTime()) * 1e-3 
+                                 << " secs" << endl;
                 }
         }
@@ -1114 +1121 @@
 
         int rayCastMethod;
-        Environment::GetSingleton()->GetIntValue("Preprocessor.rayCastMethod", rayCastMethod);
+        Environment::GetSingleton()->
+                GetIntValue("Preprocessor.rayCastMethod", rayCastMethod);
 
         if (rayCastMethod == 0)
@@ -1145 +1153 @@
         for (int i = 0; i < (int)rays.size();)
         {
+                // HACK: does not really go together with the 16 ray bundles
+                if (rays[i].mDistribution == SamplingStrategy::HW_GLOBAL_LINES_DISTRIBUTION)
+                {
+                        mGlobalLinesRenderer->CastGlobalLines(rays[i], vssRays);
+                        i ++;
+                        continue;
+                }
+
                 if (i + 16 < (int)rays.size()) 
                 {
@@ -1173 +1189 @@
         if (rays.size() > 10000) 
         {
-          cout<<endl;
-        
-        long t2 = GetTime();
+                cout << endl;
+
+                long t2 = GetTime();
 
 #if SHOW_RAYCAST_TIMING
-        if (castDoubleRays)
-                cout << 2 * rays.size() / (1e3f * TimeDiff(t1, t2)) << "M rays/s" << endl;
-        else
-                cout << rays.size() / (1e3f * TimeDiff(t1, t2)) << "M rays/s" << endl;
+                if (castDoubleRays)
+            cout << 2 * rays.size() / (1e3f * TimeDiff(t1, t2)) << "M rays/s" << endl;
+                else
+                        cout << rays.size() / (1e3f * TimeDiff(t1, t2)) << "M rays/s" << endl;
 #endif
         }
@@ -1230 +1246 @@
         ray.Init(point, direction, Ray::LOCAL_RAY);     
 }
+
 
 void Preprocessor::EvalViewCellHistogram()
@@ -1326 +1343 @@
 }
 
-}
+
+void Preprocessor::PrepareHwGlobalLines()
+{
+        int texHeight, texWidth;
+        float eps;
+        int maxDepth;
+        bool sampleReverse;
+
+        Environment::GetSingleton()->GetIntValue("Preprocessor.HwGlobalLines.texHeight", texHeight);
+        Environment::GetSingleton()->GetIntValue("Preprocessor.HwGlobalLines.texHeight", texWidth);
+        Environment::GetSingleton()->GetFloatValue("Preprocessor.HwGlobalLines.stepSize", eps);
+        Environment::GetSingleton()->GetIntValue("Preprocessor.HwGlobalLines.maxDepth", maxDepth);
+        Environment::GetSingleton()->GetBoolValue("Preprocessor.HwGlobalLines.sampleReverse", sampleReverse);
+
+        mGlobalLinesRenderer = 
+                new GlobalLinesRenderer(this,
+                                                                texHeight,
+                                                                texWidth,
+                                                                eps,
+                                                                maxDepth,
+                                                                sampleReverse);
+
+        mGlobalLinesRenderer->InitGl();
+}
+
+}

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

@@ -29 +29 @@
 class VssRay;
 class RayCaster;
-
+class GlobalLinesRenderer;
 
 
@@ -174 +174 @@
         Intersectable *GetObjectById(const int id);
 
-
+        void PrepareHwGlobalLines();
         ////////////////////////////////////////////////
 
@@ -234 +234 @@
   
         int mTotalSamples;
-  int mSamplesPerPass;
-  int mSamplesPerEvaluation;
+        int mSamplesPerPass;
+        int mSamplesPerEvaluation;
 
 protected:
@@ -253 +253 @@
         /////////////////////////
 
+        GlobalLinesRenderer *mGlobalLinesRenderer;
         RayCaster *mRayCaster;
         /// samples used for construction of the BSP view cells tree.

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

@@ -316 +316 @@
                                 OptimizeForWindowsApplication="TRUE"
                                 AdditionalIncludeDirectories="..\src;..\..\..\..\..\..\NonGTP\Devil\include;..\..\..\..\..\..\NonGTP\Zlib\include;..\..\..\..\..\..\NonGTP\Xerces;..\..\..\..\..\..\NonGTP\Boost;..\MultiLevelRayTracing;"$(QTDIR)\include\QtCore";"$(QTDIR)\include\QtGui";"$(QTDIR)\include";"$(QTDIR)\include\QtOpenGl";"$(CG_INC_PATH)""
-                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;USE_QT"
+                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;USE_QT;ATI"
                                 ExceptionHandling="TRUE"
                                 RuntimeLibrary="2"

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

@@ -18 +18 @@
 HaltonSequence ObjectDirectionBasedDistribution::sHalton;
 HaltonSequence DirectionBasedDistribution::sHalton;
+HaltonSequence HwGlobalLinesDistribution::sHalton;
 
 
 SamplingStrategy::SamplingStrategy(Preprocessor &preprocessor): 
-  mPreprocessor(preprocessor), mRatio(1.0f),  mTotalRays(0), mTotalContribution(0.0f)
-{
-  
+mPreprocessor(preprocessor), 
+mRatio(1.0f),  
+mTotalRays(0), 
+mTotalContribution(0.0f)
+{  
 }
 
@@ -415 +418 @@
         return true;
 }
-
-
 
 
@@ -839 +840 @@
 }
 
-}
-
-
+
+bool HwGlobalLinesDistribution::GenerateSample(SimpleRay &ray) 
+{
+        Vector3 origin, termination, direction; 
+
+        float radius = 0.5f * 
+                Magnitude(mPreprocessor.mViewCellsManager->GetViewSpaceBox().Size());
+
+        Vector3 center = mPreprocessor.mViewCellsManager->GetViewSpaceBox().Center();
+
+        const int tries = 1000;
+        int i;
+        for (i=0; i < tries; i++) 
+        {
+                float r[2];
+                sHalton.GetNext(2, r);
+
+                origin = center + (radius * UniformRandomVector(r[0], r[1]));
+                termination = center;
+                
+                if (0)
+                {
+                        // add a small offset to provide some more randomness in the sampling
+                        Vector3 offset(Random(radius * 1e-3f), 
+                                                   Random(radius * 1e-3f), 
+                                                   Random(radius * 1e-3f));
+                        termination += offset;
+                }
+
+                direction = termination - origin;
+
+                // $$ jb the pdf is yet not correct for all sampling methods!
+                const float c = Magnitude(direction);
+
+                if (c <= Limits::Small) 
+                        return false;
+
+                direction *= 1.0f / c;
+
+                // check if the ray intersects the view space box
+                static Ray ray;
+                ray.Init(origin, direction, Ray::LOCAL_RAY);    
+
+                float tmin, tmax;
+                if (mPreprocessor.mViewCellsManager->
+                        GetViewSpaceBox().ComputeMinMaxT(ray, &tmin, &tmax) && (tmin < tmax))
+                        break;
+        }
+
+        if (i != tries) 
+        {
+                // $$ jb the pdf is yet not correct for all sampling methods!
+                const float pdf = 1.0f;
+
+                ray = SimpleRay(origin, direction, HW_GLOBAL_LINES_DISTRIBUTION, pdf);
+                ray.mType = Ray::GLOBAL_RAY;
+                return true;
+        }
+
+        return false;
+}
+
+
+}
+
+

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

@@ -25 +25 @@
         enum 
         {
-          DUMMY_DISTRIBUTION = 0,
-          DIRECTION_BASED_DISTRIBUTION,
+                DUMMY_DISTRIBUTION = 0,
+                DIRECTION_BASED_DISTRIBUTION,
                 OBJECT_BASED_DISTRIBUTION,
                 DIRECTION_BOX_BASED_DISTRIBUTION,
@@ -39 +39 @@
                 VIEWSPACE_BORDER_BASED_DISTRIBUTION,
                 REVERSE_VIEWSPACE_BORDER_BASED_DISTRIBUTION,
-          GLOBAL_LINES_DISTRIBUTION,
-          GVS,
-          MUTATION_BASED_DISTRIBUTION
-
+                GLOBAL_LINES_DISTRIBUTION,
+                GVS,
+                MUTATION_BASED_DISTRIBUTION,
+                HW_GLOBAL_LINES_DISTRIBUTION
         };
 

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

@@ -258 +258 @@
         }
         
+        
+        bool useHwGlobalLines;
+        Environment::GetSingleton()->GetBoolValue("Preprocessor.useHwGlobalLines",
+                                                                                           useHwGlobalLines);
+
+        if (useHwGlobalLines)
+                preprocessor->PrepareHwGlobalLines();
+
         // create a preprocessor thread (note: capsulates calls to boost fuctions!)
         PreprocessorThread *pt = NULL;
 
 #ifdef TRY_GLOBAL_LINES
-        GlRenderer *renderer = new GlRenderer(preprocessor->mSceneGraph,
-                                                                                  preprocessor->mViewCellsManager,
-                                                                                  preprocessor->mKdTree);
-
-        globalLinesRenderer = new GlobalLinesRenderer(preprocessor, renderer);
+        
+        globalLinesRenderer = new GlobalLinesRenderer(preprocessor);
         globalLinesRenderer->InitGl();
         globalLinesRenderer->Run();
 
+        //delete renderer;
 #else