Changeset 1473 for GTP/trunk/Lib/Vis/Preprocessing/src/GvsPreprocessor.cpp

Timestamp:

09/22/06 16:31:02 (18 years ago)

Author:

mattausch

Message:

 

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/GvsPreprocessor.cpp (modified) (3 diffs)

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

@@ -2 +2 @@
 #include "GvsPreprocessor.h"
 #include "GlRenderer.h"
+#include "VssRay.h"
+#include "ViewCellsManager.h"
+
+
 
 namespace GtpVisibilityPreprocessor
@@ -7 +11 @@
   
 
-GvsPreprocessor::GvsPreprocessor():Preprocessor()
+GvsPreprocessor::GvsPreprocessor(): Preprocessor(), mSamplingType(0)
 {
-  environment->GetIntValue("RenderSampler.samples", mSamples);
-  cout << "number of render samples: " << mSamples << endl;
-}
-  
+        Environment::GetSingleton()->GetIntValue("RenderSampler.samples", mSamples);
+        //Environment::GetSingleton()->GetIntValue("Render.samples", mTotalSamples);
 
-void
-GvsPreprocessor::GenerateRandomRay(Ray &ray)
-{
-  int objId = RandomValue(0, mObjects.size());
-  Intersectable *object = objects[objId];
-  object->GetRandomSurfacePoint(point, normal);
-  direction = UniformRandomVector(normal);
-  SetupRay(ray, point, direction);
+        cout << "number of render samples: " << mSamples << endl;
 }
 
-void
-GvsPreprocessor::HandleRay(Ray &ray)
+
+int GvsPreprocessor::HandleRay(VssRay &ray)
 {
-  int sampleContributions = 0;
-  
-  mKdTree->CastRay(ray);
-  
-  if (ray.leaves.size()) {
-        sampleContributions += AddNodeSamples(object, ray, pass);
-    
-        if (ray.intersections.size()) {
-          sampleContributions += AddNodeSamples(ray.intersections[0].mObject, ray, pass);
+        int sampleContributions = 0;
+
+        if (mViewCellsManager->ComputeSampleContribution(ray, true, false))
+        {
+                return AdaptiveBorderSampling(ray);
         }
-  }
+        else
+        {
+                return ReverseSampling(ray);
+        }
 }
 
-void
-GvsPreprocessor::BorderSampling(Ray &ray)
+
+int GvsPreprocessor::AdaptiveBorderSampling(VssRay &ray)
 {
-  
-  
+        // TODO
+        return 0;
 }
 
-void
-GvsPreprocessor::Pass()
+
+int GvsPreprocessor::ReverseSampling(VssRay &ray)
 {
-  Ray ray;
-  while (1) {
-        AvsGenerateRay(ray);
-        HandleRay(ray);
-        while ( !mRayQueue.empty() ) {
-          Ray ray = mRayQueue.pop();
-          mRayQueue.pop();
-          AdaptiveBorderSampling(ray);
+        // TODO
+        return 0;
+}
+
+int GvsPreprocessor::CastAvsSamples(const int samplesPerPass, 
+                                                                        const int sampleType, 
+                                                                        RayQueue &passSamples)
+{
+        SimpleRayContainer simpleRays;
+        const long startTime = GetTime();
+
+        GenerateRays(samplesPerPass, sampleType, simpleRays);
+        Debug << "generated " <<  samplesPerPass << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+
+        VssRayContainer samples;
+
+        // cast the rays and optain hitpoints with geometry
+        CastRays(simpleRays, samples);
+        Debug << "cast " <<  samplesPerPass << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+
+        // add 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();
+}
+
+
+int GvsPreprocessor::Pass(const int passSamples)
+{
+        int castSamples = 0;
+        const int uniformSamples = 1000;
+
+        while (castSamples < passSamples) 
+        {
+                // Ray queue empty => 
+                // cast a number of uniform samples to fill ray Queue
+                CastAvsSamples(uniformSamples, mSamplingType, mRayQueue);
+                castSamples += Pass(passSamples);
+        }
+
+        return castSamples;
+}
+
+
+int GvsPreprocessor::RunSampling()
+{
+        int castSamples = 0;
+
+        while (!mRayQueue.empty()) 
+        {
+                // handle next ray
+                VssRay *ray = mRayQueue.top();
+                mRayQueue.pop();
+                
+                castSamples += HandleRay(*ray);
+        }
+
+        return castSamples;
 }
 
@@ -66 +113 @@
 GvsPreprocessor::ComputeVisibility()
 {
-  long startTime = GetTime();
+        Randomize(0);
+        const long startTime = GetTime();
+        
+        cout<<"Gvs Preprocessor started\n"<<flush;
+        
+        /// construct the view cells first
+        ConstructViewCells();
 
+        int samples = 0;
 
-  Debug << "type: gvs" << endl;
-  
-  cout<<"Gvs Preprocessor started\n"<<flush;
-  //  cout<<"Memory/ray "<<sizeof(VssRay)+sizeof(RssTreeNode::RayInfo)<<endl;
+        while (samples < mTotalSamples) 
+        {
+                samples += Pass(mSamplesPerPass);
+                
+                cout<<"+";
+                
+                // mVssRays.PrintStatistics(mStats);
+                //mStats << "#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl
+                //         << "#TotalSamples\n" << samples << endl;
 
-  Randomize(0);
-  
-  long startTime = GetTime();
-  
-  int totalSamples = 0;
-  
-  ConstructViewCells();
-  
-  int samples = 0;
-  int i=0;
-  while (samples < mTotalSamples) {
-        for (i=0; i < mSamplesPerPass; i++, samples++) {
-          
-          if (i%10000 == 0)
-                cout<<"+";
-          
-          Vector3 origin, direction;
-          mViewCellsManager->GetViewPoint(origin);
-          direction = UniformRandomVector();
-          
-          ViewCell *viewcell = mViewCellsManager->GetViewCell(origin);
-          
-          if (viewcell && viewcell->GetValid()) {
-                // cast rays in both directions to make the number of samples comparable
-                // with the global sampling method which also casts a "double" ray per sample
-                for (int j=0; j < 2; j++) {
-                  Intersectable *object = CastRay(origin, direction);
-                  if (object) {
-                        // if ray not outside of view space
-                        float contribution;
-                        int pvsContribution = 0;
-                        float relativePvsContribution = 0;
-                        if (object) {
-                          float pdf = 1.0f;
-                          if (viewcell->GetPvs().GetSampleContribution(object,
-                                                                                                                   pdf,
-                                                                                                                   contribution))
-                                ++pvsContribution;
-                          relativePvsContribution += contribution;
-                          viewcell->GetPvs().AddSample(object, pdf);
-                        }
-                  }
-                  direction = -direction;
-                }
-          }
-          
-          if (samples > mTotalSamples)
-                break;
+                mViewCellsManager->PrintPvsStatistics(mStats);
+                // ComputeRenderError();
         }
-        
-        //      mVssRays.PrintStatistics(mStats);
-        mStats <<
-          "#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<<
-          "#TotalSamples\n" <<samples<<endl;
 
-        mViewCellsManager->PrintPvsStatistics(mStats);
-        // ComputeRenderError();
-  }
-  
-  //  HoleSamplingPass();
-        if (0) {
-          Exporter *exporter = Exporter::GetExporter("ray-density.x3d"); 
-          exporter->SetExportRayDensity(true);
-          exporter->ExportKdTree(*mKdTree);
-          delete exporter;
-        }
-        
-        
-        // $$JB temporary removed
-        //      mViewCellsManager->PostProcess(objects, mSampleRays);
-        
-        //-- several visualizations and statistics
-        Debug << "view cells after post processing: " << endl;
-        mViewCellsManager->PrintStatistics(Debug);
-        
-        //-- render simulation after merge
-        cout << "\nevaluating bsp view cells render time after merge ... ";
-        
-        mRenderSimulator->RenderScene();
-        SimulationStatistics ss;
-        mRenderSimulator->GetStatistics(ss);
-        
-        cout << " finished" << endl;
-        cout << ss << endl;
-        Debug << ss << endl;
-        
-        // $$JB temporary removed
-        //mViewCellsManager->Visualize(objects, mSampleRays);   
-
-  return true;
+        return true;
 }