Changeset 1489 for GTP/trunk/Lib/Vis/Preprocessing/src

Timestamp:

09/26/06 10:05:29 (18 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/Lib/Vis/Preprocessing/src

Files:

• Environment.cpp (modified) (1 diff)
• GvsPreprocessor.cpp (modified) (10 diffs)
• GvsPreprocessor.h (modified) (4 diffs)
• ViewCell.cpp (modified) (2 diffs)

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

@@ -2432 +2432 @@
                                         optBool,
                                         "bvh_construction_use_global_sorting=",
-                                        "false");
+                                        "true");
 
         

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

@@ -5 +5 @@
 #include "ViewCellsManager.h"
 #include "Triangle3.h"
-
+#include "IntersectableWrapper.h"
 
 
@@ -29 +29 @@
 
 
-const bool GvsPreprocessor::DiscontinuityFound(const VssRay &ray) const
-{
+const bool GvsPreprocessor::DiscontinuityFound(const VssRay &ray, 
+                                                                                           const VssRay &oldRay) const
+{
+    //const Plane3 plane = tri->GetPlane();
         return false;
 }
@@ -52 +54 @@
 }
 
-
-void GvsPreprocessor::CreateNewSamples(VertexContainer &samples, 
-                                                                           const VssRay &ray, 
-                                                                           const Triangle3 &hitTriangle, 
-                                                                           const int index,
-                                                                           const float eps)
+/** Hepler function for adaptive border sampling. It finds 
+        new sample points around a triangle in a eps environment
+*/
+static void CreateNewSamples(VertexContainer &samples, 
+                                                         const Triangle3 &hitTriangle,
+                                                         const VssRay &ray, 
+                                                         const int index,
+                                                         const float eps)
 {
         const int indexU = (index + 1) % 3;
@@ -86 +90 @@
 
 
-int GvsPreprocessor::AdaptiveBorderSampling(const VssRay &ray)
+/** Generate rays from sample points.
+*/
+static void CreateRays(VssRayContainer &rays,
+                                           const VertexContainer &samples)
+{
+        VertexContainer::const_iterator vit, vit_end = samples.end();
+        
+        for (vit = samples.begin(); vit != vit_end; ++ vit)
+        {
+                const Vector3 currentSample = *vit;
+                VssRay *ray;// = new VssRay(ray->mOrigin, currentSample);
+        }
+}
+
+
+int GvsPreprocessor::AdaptiveBorderSampling(const VssRay &prevRay)
 {
         cout << "a";
-        //Intersectable *tObj = ray->GetTerminationObject;
+        Intersectable *tObj = prevRay.mTerminationObject;
         Triangle3 hitTriangle;
-        vector<Vector3> samples;
+
+        // other types not implemented yet
+        if (tObj->Type() == Intersectable::TRIANGLE_INTERSECTABLE)
+        {
+                hitTriangle = dynamic_cast<TriangleIntersectable *>(tObj)->GetItem();
+        }
+
+        VertexContainer samples;
         samples.reserve(9);
 
-        CreateNewSamples(samples, ray, hitTriangle, 0, mEps);
-        CreateNewSamples(samples, ray, hitTriangle, 1, mEps);
-        CreateNewSamples(samples, ray, hitTriangle, 2, mEps);
-
-        VertexContainer::const_iterator vit, vit_end = samples.end();
-        
-        for (vit = samples.begin(); vit != vit_end; ++ vit)
-        {
-                VssRay *ray;// = CreateRay(*vit);
-
-                if (DiscontinuityFound(*ray))
-                {
-                        // schedule for reverse sampling
-                        mRayQueue.push(GvsRayInfo(ray, true));
-                }
-                else
-                {
-                        // schedule for adaptive border sampling
-                        mRayQueue.push(GvsRayInfo(ray, false));
-                }
-        }
-
-        // TODO
-        return 1;
+        CreateNewSamples(samples, hitTriangle, prevRay, 0, mEps);
+        CreateNewSamples(samples, hitTriangle, prevRay, 1, mEps);
+        CreateNewSamples(samples, hitTriangle, prevRay, 2, mEps);
+
+        VssRayContainer vssRays;
+        CreateRays(vssRays, samples);
+
+        VssRayContainer::const_iterator rit, rit_end = vssRays.end();
+        
+        for (rit = vssRays.begin(); rit != rit_end; ++ rit)
+        {
+                VssRay *ray = *rit;
+
+                // discontinuity found? 
+                // schedule for reverse sampling or adaptive border sampling
+                const bool gap = DiscontinuityFound(*ray, prevRay);
+                mRayQueue.push(GvsRayInfo(ray, gap));
+        }
+
+        return 9;
 }
 
@@ -128 +150 @@
 }
 
-int GvsPreprocessor::CastAvsSamples(const int samplesPerPass, 
-                                                                        const int sampleType, 
-                                                                        RayQueue &passSamples)
-{
+
+int GvsPreprocessor::CastInitialSamples(const int numSamples, 
+                                                                                const int sampleType)
+{       
+        const long startTime = GetTime();
+
+        // generate simple rays
         SimpleRayContainer simpleRays;
-        const long startTime = GetTime();
-
-        GenerateRays(samplesPerPass, sampleType, simpleRays);
-        Debug << "generated " <<  samplesPerPass << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-
-        // cast the rays and optain hitpoints with geometry
+        GenerateRays(numSamples, sampleType, simpleRays);
+        
+        // generate vss rays
         VssRayContainer samples;
         CastRays(simpleRays, samples);
-
-        Debug << "cast " <<  samplesPerPass << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-
+        
+        // add to ray queue
+        EnqueueSamples(samples);
+
+        Debug << "generated " <<  numSamples << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+
+        return (int)samples.size();
+}
+
+
+void GvsPreprocessor::EnqueueSamples(VssRayContainer &samples, VssRay *oldRay)
+{
         // add samples to ray queue
         VssRayContainer::const_iterator vit, vit_end = samples.end();
         for (vit = samples.begin(); vit != vit_end; ++ vit)
         {
-                mRayQueue.push(*vit);
-        }
-
-        return (int)mRayQueue.size();
+                /// if there is no old ray, no discontinuity
+                const bool gap = oldRay ? DiscontinuityFound(*(*vit), *oldRay) : false;
+                mRayQueue.push(GvsRayInfo(*vit, gap));
+        }
+
 }
 
@@ -158 +190 @@
 {
         int castSamples = 0;
-        
+        const int mSampleType = 0;
         while (castSamples < mSamplesPerPass) 
         {
                 // Ray queue empty => 
                 // cast a number of uniform samples to fill ray Queue
-                CastAvsSamples(mInitialSamples, mSamplingType, mRayQueue);
-                
-                const int gvsSamples = RunSampling();
+                CastInitialSamples(mInitialSamples, mSampleType);
+
+                const int gvsSamples = ProcessQueue();
                 castSamples += gvsSamples;
-                //cout << "\ngvs samples: " << gvsSamples << endl;
-                //cout << "cast " << castSamples << " of " << mSamplesPerPass << endl;
+                //cout << "\ncast " << castSamples << " of " << mSamplesPerPass << endl;
         }
 
@@ -175 +206 @@
 
 
-int GvsPreprocessor::RunSampling()
+int GvsPreprocessor::ProcessQueue()
 {
         int castSamples = 0;
@@ -182 +213 @@
         {
                 // handle next ray
-                VssRay *ray = mRayQueue.top();
+                GvsRayInfo rayInfo = mRayQueue.top();
                 mRayQueue.pop();
                 
-                castSamples += HandleRay(*ray);
+                castSamples += HandleRay(rayInfo);
         }
 
@@ -192 +223 @@
 
 
-bool
-GvsPreprocessor::ComputeVisibility()
+bool GvsPreprocessor::ComputeVisibility()
 {
         Randomize(0);
@@ -213 +243 @@
                 const int passSamples = Pass();
                 castSamples += passSamples;
+                
+                /////////////
+                // -- stats
                 cout << "+";
                 cout << "\nsamples cast " << passSamples << " (=" << castSamples << " of " << mTotalSamples << ")" << endl;
                 //mVssRays.PrintStatistics(mStats);
-                //mStats << "#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl
-                //         << "#TotalSamples\n" << samples << endl;
+                mStats << "#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl
+                           << "#TotalSamples\n" << castSamples << endl;
 
                 mViewCellsManager->PrintPvsStatistics(mStats);

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

@@ -12 +12 @@
 class Exporter;
 class VssRay;
+
 
 
@@ -31 +32 @@
         struct GvsRayInfo
         {
+                GvsRayInfo(VssRay *ray, const bool d)
+                        : mRay(ray), mFoundDiscontinuity(d) 
+                {}
+
                 VssRay *mRay;
                 bool mFoundDiscontinuity;
-        }
+        };
 
-        
+
         typedef stack<GvsRayInfo> RayQueue;
 
-        /** Runs the adaptive sampling. The method starts with a number of random rays given
-                by the queue and continues as long it finds new visible geometry (i.e., the queue is
-                not empty).
+        /** Runs the adaptive sampling until the ray queue is empty. 
+                The method starts with a number of random rays given
+                by the queue and continues as long it finds new visible geometry 
+                (i.e., the queue is     not empty).
 
                 @returns the number of samples cast.
         */
-        int RunSampling();
+        int ProcessQueue();
 
-        /** One pass of the sampling preprocessor. Continues as long as at least passSample
-                rays have been cast.
+        /** One pass of the sampling preprocessor. 
+                Continues as long as at least passSample rays have been cast.
                 @returns the number of samples cast.
         */
@@ -54 +60 @@
         /** Generates the rays starting the adaptive visibility sampling process.
         */
-        int CastAvsSamples(
-                const int samplesPerPass, 
-                const int sampleType, 
-                RayQueue &passSamples);
+        int CastInitialSamples(const int numSamples, const int sampleType);
 
         /** Uses the information gained from the ray for doing adaptive border sampling.
@@ -70 +73 @@
         int HandleRay(const GvsRayInfo &ray);
 
-        /** 
+        /** The adaptive border sampling step. It aims to find neighbouring 
+                triangles of the one hit by the previous ray.
         */      
-        int AdaptiveBorderSampling(const VssRay &ray);
+        int AdaptiveBorderSampling(const VssRay &prevRay);
         
-        int ReverseSampling(const VssRay &ray);
+        /** The reverse sampling step. It is started once the cast
+                ray finds a discontinuity, i.e., a closer triangle.
+                Then the process tries to find a ray from the old
+                triangle passing through a gap.
+        */
+        int ReverseSampling(const VssRay &prevRay);
 
-        /** Cast samples according to a specific sampling strategy.
+        /** Returns true if we sampled a closer triangle than with the previous ray.
         */
-        int CastPassSamples(
-                const int samplesPerPass, 
-                const int sampleType, 
-                VssRayContainer &passSamples) const;
+        const bool DiscontinuityFound(const VssRay &ray, const VssRay &prevRay) const;
 
-        void CreateNewSamples(
-                VertexContainer &samples, 
-                const VssRay &ray, 
-                const Triangle3 &hitTriangle, 
-                const int index,
-                const float eps);
-
-        const bool DiscontinuityFound(const VssRay &ray) const;
-
-
+        /** Adds new samples to the ray queue and classifies them
+                with respect to the previous ray.
+        */
+        void EnqueueSamples(VssRayContainer &samples, VssRay *prevRay = NULL);
+        
         //////////////////////
 

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

@@ -1485 +1485 @@
 {
          stats << "#Pass\n" << pass << endl
-                //<< "#Merged\n" << mergeStats.merged << endl 
                 << "#ViewCells\n" << viewCells << endl 
         << "#RenderCostDecrease\n" << renderCostDecrease << endl // TODO
@@ -1499 +1498 @@
                 << endl;
 }
+
 
 void ViewCellsTree::ExportStats(const string &mergeStats)