Changeset 492 for trunk/VUT/GtpVisibilityPreprocessor/src/RssPreprocessor.cpp

Timestamp:

01/03/06 23:33:45 (18 years ago)

Author:

bittner

Message:

Large merge - viewcells seem not functional now

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/RssPreprocessor.cpp (modified) (22 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/RssPreprocessor.cpp

@@ -11 +11 @@
 #include "ViewCellsManager.h"
 #include "RenderSimulator.h"
+#include "GlRenderer.h"
 
 static bool useViewSpaceBox = false;
@@ -33 +34 @@
   environment->GetIntValue("RssPreprocessor.Export.numRays", mExportNumRays);
   environment->GetBoolValue("RssPreprocessor.useViewcells", mUseViewcells);
-  environment->GetBoolValue("RssPreprocessor.useViewcells", mUseViewcells);
+  environment->GetBoolValue("RssPreprocessor.objectBasedSampling", mObjectBasedSampling);
+  environment->GetBoolValue("RssPreprocessor.directionalSampling", mDirectionalSampling);
 
   environment->GetBoolValue("RssPreprocessor.loadInitialSamples", mLoadInitialSamples);
@@ -39 +41 @@
   
   mStats.open("stats.log");
+
 }
 
 RssPreprocessor::~RssPreprocessor()
 {
-  CLEAR_CONTAINER(mVssRays);
+  // mVssRays get deleted in the tree
+  //  CLEAR_CONTAINER(mVssRays);
 }
 
@@ -78 +82 @@
   Vector3 pointA, pointB;
   float bsize = Magnitude(box.Size());
+
   
   if (mKdTree->CastRay(ray)) {
@@ -86 +91 @@
         // compute intersection with the scene bounding box
         float tmin, tmax;
-        box.ComputeMinMaxT(ray, &tmin, &tmax);
-        if (tmax > bsize) {
-          //cerr<<"Warning: tmax > box size tmax="<<tmax<<" tmin="<<tmin<<" size="<<bsize<<endl;
-          //cerr<<"ray"<<ray<<endl;
-        }
-        pointA = ray.Extrap(tmax);
+        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
+          pointA = ray.Extrap(tmax);
+        else
+          return 0;
   }
 
@@ -108 +111 @@
         objectB = NULL;
         float tmin, tmax;
-        box.ComputeMinMaxT(ray, &tmin, &tmax);
-        if (tmax > bsize) {
-          //cerr<<"Warning: tmax > box size tmax="<<tmax<<" tmin="<<tmin<<" size="<<bsize<<endl;
-          //cerr<<"ray"<<ray<<endl;
-        }
-        pointB = ray.Extrap(tmax);
-  }
-
+        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
+          pointB = ray.Extrap(tmax);
+        else
+          return 0;
+  }
+
+  //  if (objectA == NULL && objectB != NULL) {
+  if (1) {
+        // cast again to ensure that there is no objectA
+        SetupRay(ray, pointB, direction);
+        if (mKdTree->CastRay(ray)) {
+          objectA = ray.intersections[0].mObject;
+          pointA = ray.Extrap(ray.intersections[0].mT);
+        }
+  }
+  
+  
   VssRay *vssRay  = NULL;
 
-  bool validSample = true;
-  if (detectEmptyViewSpace) {
+  bool validSample = (objectA != objectB);
+  if (0 && detectEmptyViewSpace) {   // consider all samples valid
         // check if the viewpoint lies on the line segment AB
         if (Distance(pointA, pointB) <
@@ -176 +188 @@
   Vector3 point;
   if (!use2dSampling) {
-        Vector3 normal;
-        int i = (int)RandomValue(0, (Real)((int)mObjects.size()-1));
-        Intersectable *object = mObjects[i];
-        object->GetRandomSurfacePoint(point, normal);
+        if (mObjectBasedSampling) {
+          Vector3 normal;
+          int i = RandomValue(0, mObjects.size()-1);
+          Intersectable *object = mObjects[i];
+          object->GetRandomSurfacePoint(point, normal);
+        } else {
+          // select
+          if (mDirectionalSampling) {
+                point = viewpoint + UniformRandomVector();
+          } else {
+                // select the other point uniformly distruted in the whole viewspace
+                AxisAlignedBox3 box;
+                
+                if (viewSpaceBox)
+                  box =*viewSpaceBox;
+                else 
+                  box = mKdTree->GetBox();
+                
+                point = box.GetRandomPoint();
+          }
+        }
   } else {
         AxisAlignedBox3 box;
@@ -187 +216 @@
         else 
           box = mKdTree->GetBox();
-                
+        
         point = box.GetRandomPoint();
         point.y = viewpoint.y;
   }
         
+  return point - viewpoint;
+}
+
+Vector3
+RssPreprocessor::InitialGetDirection(const Vector3 &viewpoint,
+                                                                         AxisAlignedBox3 *viewSpaceBox
+                                                                         )
+{
+  Vector3 point;
+  if (!use2dSampling) {
+        if (1 || mObjectBasedSampling) {
+          Vector3 normal;
+          int i = RandomValue(0, mObjects.size()-1);
+          Intersectable *object = mObjects[i];
+          object->GetRandomSurfacePoint(point, normal);
+        } else {
+          // select
+          if (1 || mDirectionalSampling) {
+                point = viewpoint + UniformRandomVector();
+          } else {
+                // select the other point uniformly distruted in the whole viewspace
+                AxisAlignedBox3 box;
+                
+                if (viewSpaceBox)
+                  box =*viewSpaceBox;
+                else 
+                  box = mKdTree->GetBox();
+                
+                point = box.GetRandomPoint();
+          }
+        }
+  } else {
+        AxisAlignedBox3 box;
+        
+        if (viewSpaceBox)
+          box =*viewSpaceBox;
+        else 
+          box = mKdTree->GetBox();
+        
+        point = box.GetRandomPoint();
+        point.y = viewpoint.y;
+  }
+  
   return point - viewpoint;
 }
@@ -203 +275 @@
   int num;
 
-
-  
-  float avgPvsSize;
-  float avgRayContribution;
-  float avgPvsEntropy;
-  float avgRayLengthEntropy;
-  float avgImportance;
-  float avgRays;
-  rssTree->GetTreeStatistics(
-                                                         avgPvsSize,
-                                                         avgRays,
-                                                         avgRayContribution,
-                                                         avgPvsEntropy,
-                                                         avgRayLengthEntropy,
-                                                         avgImportance);
-  
+  rssTree->UpdateTreeStatistics();
+
   cout<<
-        "#RSS_AVG_PVS_SIZE\n"<<avgPvsSize<<endl<<
-        "#RSS_AVG_RAYS\n"<<avgRays<<endl<<
-        "#RSS_AVG_RAY_CONTRIB\n"<<avgRayContribution<<endl<<
-        "#RSS_AVG_PVS_ENTROPY\n"<<avgPvsEntropy<<endl<<
-        "#RSS_AVG_RAY_LENGTH_ENTROPY\n"<<avgRayLengthEntropy<<endl<<
-        "#RSS_AVG_IMPORTANCE\n"<<avgImportance<<endl;
+        "#RSS_AVG_PVS_SIZE\n"<<rssTree->stat.avgPvsSize<<endl<<
+        "#RSS_AVG_RAYS\n"<<rssTree->stat.avgRays<<endl<<
+        "#RSS_AVG_RAY_CONTRIB\n"<<rssTree->stat.avgRayContribution<<endl<<
+        "#RSS_AVG_PVS_ENTROPY\n"<<rssTree->stat.avgPvsEntropy<<endl<<
+        "#RSS_AVG_RAY_LENGTH_ENTROPY\n"<<rssTree->stat.avgRayLengthEntropy<<endl<<
+        "#RSS_AVG_IMPORTANCE\n"<<rssTree->stat.avgImportance<<endl;
   
   if (0) {
-        float p = desiredSamples/(float)(avgRayContribution*rssTree->stat.Leaves());
+        float p = desiredSamples/(float)(rssTree->stat.avgRayContribution*rssTree->stat.Leaves());
         num = rssTree->GenerateRays(p, rays);
   } else {
@@ -249 +307 @@
   cout<<"Exporting vss rays..."<<endl<<flush;
         
-  float prob = number/(float)vssRays.size();
-
-
   Exporter *exporter = NULL;
   exporter = Exporter::GetExporter(filename);
@@ -266 +321 @@
   }
         
-  VssRayContainer rays; for (int i=0; i < vssRays.size(); i++)
-        if (RandomValue(0,1) < prob)
-          rays.push_back(vssRays[i]);
+  VssRayContainer rays;
+  
+  vssRays.SelectRays( number, rays);
 
   exporter->ExportRays(rays, RgbColor(1, 0, 0));
@@ -388 +443 @@
 }
 
+
+void
+RssPreprocessor::ComputeRenderError()
+{
+  // compute rendering error
+  if (renderer) {
+        emit EvalPvsStat();
+        QMutex mutex;
+        mutex.lock();
+        renderer->mRenderingFinished.wait(&mutex);
+        mutex.unlock();
+        mStats <<
+          "#AvgPvsRenderError\n" <<renderer->mPvsStat.GetAvgError()<<endl<<
+          "#MaxPvsRenderError\n" <<renderer->mPvsStat.GetMaxError()<<endl<<
+          "#ErrorFreeFrames\n" <<renderer->mPvsStat.GetErrorFreeFrames()<<endl;
+  }
+}
+
 bool
 RssPreprocessor::ComputeVisibility()
 {
+  
+  connect(this, SIGNAL(EvalPvsStat()), renderer, SLOT(EvalPvsStat()) );
+  
   cout<<"Rss Preprocessor started\n"<<flush;
   cout<<"Memory/ray "<<sizeof(VssRay)+sizeof(RssTreeNode::RayInfo)<<endl;
-  mSceneGraph->CollectObjects(&mObjects);
+
+  Randomize(0);
+  
         
   long startTime = GetTime();
@@ -443 +521 @@
 
   RssTree *rssTree = NULL;
-
-  if (mLoadInitialSamples)
-  {
-          cout << "Loading samples from file ... ";
-          LoadSamples(mVssRays, mObjects);
-          cout << "finished\n" << endl;
-  }
-  else
-  {
+  int rssPass = 0;
+  int rssSamples = 0;
+
+#if 0
+  if (mLoadInitialSamples) {
+        cout << "Loading samples from file ... ";
+        LoadSamples(mVssRays, mObjects);
+        cout << "finished\n" << endl;
+  } else {
+#endif
         while (totalSamples < mInitialSamples) {
-                int passContributingSamples = 0;
-                int passSampleContributions = 0;
-                int passSamples = 0;
-                int index = 0;
-                        
-                int sampleContributions;
-                        
-                int s = Min(mSamplesPerPass, mInitialSamples);
-                for (int k=0; k < s; k++) {
-                                
+          int passContributingSamples = 0;
+          int passSampleContributions = 0;
+          int passSamples = 0;
+          int index = 0;
+          
+          int sampleContributions;
+          
+          //int s = Min(mSamplesPerPass, mInitialSamples);
+          int s = mInitialSamples;
+          
+          for (int k=0; k < s; k++) {
+                
+                
                 //Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
                 Vector3 viewpoint; 
-                mViewCellsManager->GetViewPoint(viewpoint);
-                Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
-                                
+                //              mViewCellsManager->GetViewPoint(viewpoint);
+                viewpoint = GetViewpoint(mViewSpaceBox);
+                Vector3 direction = InitialGetDirection(viewpoint, mViewSpaceBox);
+                
                 sampleContributions = CastRay(viewpoint, direction, mVssRays);
-                                
-                                
+                
+                
                 //-- CORR matt: put block inside loop
                 if (sampleContributions) {
-                        passContributingSamples ++;
-                        passSampleContributions += sampleContributions;
+                  passContributingSamples ++;
+                  passSampleContributions += sampleContributions;
                 }
                 passSamples++;
                 totalSamples++;
-                }
-            
-                        
-                float avgRayContrib = (passContributingSamples > 0) ? 
+          }
+          
+          
+          float avgRayContrib = (passContributingSamples > 0) ? 
                 passSampleContributions/(float)passContributingSamples : 0;
-                        
-                cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
-                cout << "#TotalSamples=" << totalSamples/1000 
-                        << "k   #SampleContributions=" << passSampleContributions << " (" 
-                        << 100*passContributingSamples/(float)passSamples<<"%)" 
-                        << "avgcontrib=" << avgRayContrib << endl;
-                        
-                mStats <<
+          
+          cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
+          cout << "#TotalSamples=" << totalSamples/1000 
+                   << "k   #SampleContributions=" << passSampleContributions << " (" 
+                   << 100*passContributingSamples/(float)passSamples<<"%)" 
+                   << "avgcontrib=" << avgRayContrib << endl;
+          
+          mPass++;
+        }
+          
+        cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
+        cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl <<flush;
+        
+        rssSamples += mVssRays.size();
+        
+        
+        if (mExportRays) {
+          char filename[64];
+          sprintf(filename, "rss-rays-initial.x3d");
+          ExportRays(filename, mVssRays, mExportNumRays);
+        }
+        
+        if (mStoreInitialSamples)
+          {
+                cout << "Writing samples to file ... ";
+                WriteSamples(mVssRays);
+                cout << "finished\n" << endl;
+          }
+        
+        if (mUseViewcells) {
+          // construct view cells
+          mViewCellsManager->Construct(mObjects, mVssRays);
+          // evaluate contributions of the intitial rays
+          mViewCellsManager->ComputeSampleContributions(mVssRays);
+          
+          
+          mStats <<
                 "#Pass\n" <<mPass<<endl<<
-                "#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl<<
-                "#TotalSamples\n" << totalSamples<< endl<<
-                "#SampleContributions\n" << passSampleContributions << endl << 
-                "#PContributingSamples\n"<<100*passContributingSamples/(float)passSamples<<endl <<
-                "#AvgRayContrib\n" << avgRayContrib << endl;
-                
-                mPass++;
-
-        }
-  
-        cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
-  }
-
-  cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl <<flush;
-  
-
-  if (mExportRays) {
-        char filename[64];
-        sprintf(filename, "rss-rays-initial.x3d");
-        ExportRays(filename, mVssRays, mExportNumRays);
-  }
-  
-  if (mStoreInitialSamples)
-  {
-          cout << "Writing samples to file ... ";
-          WriteSamples(mVssRays);
-          cout << "finished\n" << endl;
-  }
-
-  if (mUseViewcells) {
-        // construct view cells
-        mViewCellsManager->Construct(mObjects, mVssRays);
-        
+                "#RssPass\n" <<rssPass<<endl<<
+                "#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<<
+                "#TotalSamples\n" <<totalSamples<<endl<<
+                "#RssSamples\n" <<rssSamples<<endl;
+          
+        ComputeRenderError();
+
+        mVssRays.PrintStatistics(mStats);
+        mViewCellsManager->PrintPvsStatistics(mStats);
+
         VssRayContainer selectedRays;
         int desired = Max(
                                           mViewCellsManager->GetPostProcessSamples(),
                                           mViewCellsManager->GetVisualizationSamples());
-        float p = desired/(float)mVssRays.size();
-        
-        for (int i=0; i < mVssRays.size(); i++) {
-          if (Random(1.0f) < p)
-                selectedRays.push_back(mVssRays[i]);
-        }
+
+        mVssRays.SelectRays(desired, selectedRays);
+        
         //-- post process view cells
         mViewCellsManager->PostProcess(mObjects, selectedRays);
@@ -547 +633 @@
 
 
+  
+  rssPass++;
+  
   rssTree = new RssTree;
-        
+  rssTree->SetPass(mPass);
+  
   if (mUseImportanceSampling) {
         
@@ -555 +645 @@
         else
           rssTree->Construct(mVssRays, NULL);
+
+        rssTree->stat.Print(mStats);
         cout<<"RssTree root PVS size = "<<rssTree->GetRootPvsSize()<<endl;
         
@@ -572 +664 @@
   // viewcells->UpdatePVS(newVssRays);
   
-  int rssPass = 0;
-  int rssSamples = 0;
+
   while (1) {
         int num = mRssSamplesPerPass;
         SimpleRayContainer rays;
         VssRayContainer vssRays;
-                
+
+
         if (!mUseImportanceSampling) {
           for (int j=0; j < num; j++) {
@@ -597 +689 @@
 
         
-        totalSamples+=num;
-        rssSamples+=num;
-
+        totalSamples += rays.size();
+        rssSamples += vssRays.size();
+
+        
+        
         mStats <<
           "#Pass\n" <<mPass<<endl<<
@@ -607 +701 @@
           "#RssSamples\n" <<rssSamples<<endl;
 
+
         if (mUseViewcells) {
           
@@ -616 +711 @@
         }
 
-        // add rays to the tree after the viewcells have been cast to have their contributions
-        // already when adding into the tree
-        // do not add those rays which have too low or no contribution....
-        
-        if (mUseImportanceSampling) {
-          rssTree->AddRays(vssRays);
-          
-          if (0) {
-                cout<<"############# Rss PVS STAT ##################\n";
-                cout<<"#AVG_RSS_PVS\n"<<rssTree->GetAvgPvsSize()<<endl;
-                cout<<"#RSS_ROOT_PVS\n"<<rssTree->GetRootPvsSize()<<endl;
-          }
-          
-          if (mUpdateSubdivision) {
-                int subdivided = rssTree->UpdateSubdivision();
-                cout<<"subdivided leafs = "<<subdivided<<endl;
-                cout<<"#total leaves = "<<rssTree->stat.Leaves()<<endl;
-          }
-        }
-        
+
+        ComputeRenderError();
+        
+        // epxort rays before adding them to the tree -> some of them can be deleted
+
         if (mExportRays) {
           char filename[64];
@@ -644 +724 @@
           
           ExportRays(filename, vssRays, mExportNumRays);
-        }
+
+          // now export all contributing rays
+          VssRayContainer contributingRays;
+          vssRays.GetContributingRays(contributingRays, mPass);
+          mStats<<"#NUM_CONTRIBUTING_RAYS\n"<<contributingRays.size()<<endl;
+          sprintf(filename, "rss-crays-%04d.x3d", rssPass);
+          ExportRays(filename, contributingRays, mExportNumRays);
+        }
+
+        
+        // add rays to the tree after the viewcells have been cast to have their contributions
+        // already when adding into the tree
+        // do not add those rays which have too low or no contribution....
+        
+        if (mUseImportanceSampling) {
+          rssTree->AddRays(vssRays);
+          
+          if (0) {
+                cout<<"############# Rss PVS STAT ##################\n";
+                cout<<"#AVG_RSS_PVS\n"<<rssTree->GetAvgPvsSize()<<endl;
+                cout<<"#RSS_ROOT_PVS\n"<<rssTree->GetRootPvsSize()<<endl;
+          }
+          
+          
+          if (mUpdateSubdivision) {
+                int updatePasses = 1;
+                if (mPass % updatePasses == 0) {
+                  int subdivided = rssTree->UpdateSubdivision();
+                  cout<<"subdivided leafs = "<<subdivided<<endl;
+                  cout<<"#total leaves = "<<rssTree->stat.Leaves()<<endl;
+                }
+          }
+        }
+        
 
         
@@ -653 +766 @@
         }
 
+        
+        if (!mUseImportanceSampling) 
+          CLEAR_CONTAINER(vssRays);
+
         if (totalSamples >= mRssSamples + mInitialSamples)
           break;
@@ -659 +776 @@
         rssPass++;
         mPass++;
+        rssTree->SetPass(mPass);
   }