source: GTP/trunk/Lib/Vis/Preprocessing/src/RssPreprocessor.cpp @ 718

Revision 718, 20.1 KB checked in by bittner, 18 years ago (diff)

fixed double counting of sample contributions - important for proper importance sampling with directional focus
Line 
1#include "SceneGraph.h"
2#include "KdTree.h"
3#include "RssPreprocessor.h"
4#include "X3dExporter.h"
5#include "Environment.h"
6#include "MutualVisibility.h"
7#include "Polygon3.h"
8#include "ViewCell.h"
9#include "VssRay.h"
10#include "RssTree.h"
11#include "ViewCellsManager.h"
12#include "RenderSimulator.h"
13#include "GlRenderer.h"
14
15static bool useViewSpaceBox = false;
16static bool use2dSampling = false;
17
18
19// not supported anymore!
20static bool fromBoxVisibility = false;
21
22
23RssPreprocessor::RssPreprocessor():
24  mPass(0),
25  mVssRays()
26{
27  // this should increase coherence of the samples
28  environment->GetIntValue("RssPreprocessor.samplesPerPass", mSamplesPerPass);
29  environment->GetIntValue("RssPreprocessor.initialSamples", mInitialSamples);
30  environment->GetIntValue("RssPreprocessor.vssSamples", mRssSamples);
31  environment->GetIntValue("RssPreprocessor.vssSamplesPerPass", mRssSamplesPerPass);
32  environment->GetBoolValue("RssPreprocessor.useImportanceSampling", mUseImportanceSampling);
33
34  environment->GetBoolValue("RssPreprocessor.Export.pvs", mExportPvs);
35  environment->GetBoolValue("RssPreprocessor.Export.rssTree", mExportRssTree);
36  environment->GetBoolValue("RssPreprocessor.Export.rays", mExportRays);
37  environment->GetIntValue("RssPreprocessor.Export.numRays", mExportNumRays);
38  environment->GetBoolValue("RssPreprocessor.useViewcells", mUseViewcells);
39  environment->GetBoolValue("RssPreprocessor.objectBasedSampling", mObjectBasedSampling);
40  environment->GetBoolValue("RssPreprocessor.directionalSampling", mDirectionalSampling);
41
42  environment->GetBoolValue("RssPreprocessor.loadInitialSamples", mLoadInitialSamples);
43  environment->GetBoolValue("RssPreprocessor.storeInitialSamples", mStoreInitialSamples);
44  environment->GetBoolValue("RssPreprocessor.updateSubdivision", mUpdateSubdivision);
45 
46  mStats.open("stats.log");
47  mRssTree = NULL;
48}
49
50
51bool
52RssPreprocessor::GenerateRays(
53                                                          const int number,
54                                                          const int sampleType,
55                                                          SimpleRayContainer &rays
56                                                          )
57{
58  bool result = false;
59
60  switch (sampleType) {
61  case RSS_BASED_DISTRIBUTION:
62  case RSS_SILHOUETTE_BASED_DISTRIBUTION:
63        if (mRssTree) {
64          GenerateImportanceRays(mRssTree, number, rays);
65          result = true;
66          //      rays.NormalizePdf();
67        }
68        break;
69  default:
70        result = Preprocessor::GenerateRays(number, sampleType, rays);
71  }
72
73  return result;
74}
75
76void
77RssPreprocessor::CastRays(
78                                                  SimpleRayContainer &rays,
79                                                  VssRayContainer &vssRays
80                                                  )
81{
82  for (int i=0; i < rays.size(); i++)
83        CastRay(rays[i].mOrigin, rays[i].mDirection, rays[i].mPdf, vssRays);
84}
85
86
87RssPreprocessor::~RssPreprocessor()
88{
89  // mVssRays get deleted in the tree
90  //  CLEAR_CONTAINER(mVssRays);
91}
92
93void
94RssPreprocessor::SetupRay(Ray &ray,
95                                                  const Vector3 &point,
96                                                  const Vector3 &direction
97                                                  )
98{
99  ray.intersections.clear();
100  // do not store anything else then intersections at the ray
101  ray.Init(point, direction, Ray::LOCAL_RAY);
102}
103
104int
105RssPreprocessor::CastRay(
106                                                 Vector3 &viewPoint,
107                                                 Vector3 &direction,
108                                                 const float probability,
109                                                 VssRayContainer &vssRays
110                                                 )
111{
112  int hits = 0;
113  static Ray ray;
114  AxisAlignedBox3 box = mKdTree->GetBox();
115
116  AxisAlignedBox3 sbox = box;
117  sbox.Enlarge(Vector3(-Limits::Small));
118  if (!sbox.IsInside(viewPoint))
119        return 0;
120       
121  SetupRay(ray, viewPoint, direction);
122
123  if (!mDetectEmptyViewSpace)
124        ray.mFlags &= ~Ray::CULL_BACKFACES;
125  else
126        ray.mFlags |= Ray::CULL_BACKFACES;
127
128
129  // cast ray to KD tree to find intersection with other objects
130  Intersectable *objectA, *objectB;
131  Vector3 pointA, pointB;
132  float bsize = Magnitude(box.Size());
133
134 
135  if (mKdTree->CastRay(ray)) {
136        objectA = ray.intersections[0].mObject;
137        pointA = ray.Extrap(ray.intersections[0].mT);
138  } else {
139        objectA = NULL;
140        // compute intersection with the scene bounding box
141        float tmin, tmax;
142        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
143          pointA = ray.Extrap(tmax);
144        else
145          return 0;
146  }
147
148
149  if (mDetectEmptyViewSpace) {
150        SetupRay(ray, pointA, -direction);
151  } else
152        SetupRay(ray, viewPoint, -direction);
153       
154  if (!mDetectEmptyViewSpace)
155        ray.mFlags &= ~Ray::CULL_BACKFACES;
156  else
157        ray.mFlags |= Ray::CULL_BACKFACES;
158
159  if (mKdTree->CastRay(ray)) {
160        objectB = ray.intersections[0].mObject;
161        pointB = ray.Extrap(ray.intersections[0].mT);
162  } else {
163        objectB = NULL;
164        float tmin, tmax;
165        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
166          pointB = ray.Extrap(tmax);
167        else
168          return 0;
169  }
170
171  //  if (objectA == NULL && objectB != NULL) {
172  if (mDetectEmptyViewSpace) {
173        // cast again to ensure that there is no objectA
174        SetupRay(ray, pointB, direction);
175        ray.mFlags |= Ray::CULL_BACKFACES;
176        if (mKdTree->CastRay(ray)) {
177          objectA = ray.intersections[0].mObject;
178          pointA = ray.Extrap(ray.intersections[0].mT);
179        }
180  }
181 
182 
183  VssRay *vssRay  = NULL;
184
185  bool validSample = (objectA != objectB);
186  if (validSample) {
187        if (objectA) {
188          vssRay = new VssRay(pointB,
189                                                  pointA,
190                                                  objectB,
191                                                  objectA,
192                                                  mPass,
193                                                  probability
194                                                  );
195          vssRays.push_back(vssRay);
196          hits ++;
197
198        }
199       
200        if (objectB) {
201          vssRay = new VssRay(pointA,
202                                                  pointB,
203                                                  objectA,
204                                                  objectB,
205                                                  mPass,
206                                                  probability
207                                                  );
208          vssRays.push_back(vssRay);
209          hits ++;
210        }
211  }
212 
213  return hits;
214}
215
216
217void
218RssPreprocessor::ExportObjectRays(VssRayContainer &rays,
219                                                                  const int objectId)
220{
221  ObjectContainer::const_iterator oi;
222
223  Intersectable *object = NULL;
224  for (oi = mObjects.begin(); oi != mObjects.end(); ++oi)
225        if (objectId == (*oi)->GetId()) {
226          object = *oi;
227          break;
228        }
229
230  if (object == NULL)
231        return;
232 
233  VssRayContainer selectedRays;
234  VssRayContainer::const_iterator it= rays.begin(), it_end = rays.end();
235
236 
237  for (; it != it_end; ++it) {
238        if ((*it)->mTerminationObject == object)
239          selectedRays.push_back(*it);
240  }
241 
242
243  Exporter *exporter = Exporter::GetExporter("object-rays.x3d");
244  //    exporter->SetWireframe();
245  //    exporter->ExportKdTree(*mKdTree);
246  exporter->SetFilled();
247  exporter->ExportIntersectable(object);
248  exporter->ExportRays(selectedRays, RgbColor(1, 0, 0));
249 
250  delete exporter;
251 
252}
253
254
255int
256RssPreprocessor::GenerateImportanceRays(RssTree *rssTree,
257                                                                                const int desiredSamples,
258                                                                                SimpleRayContainer &rays
259                                                                                )
260{
261  int num;
262
263  rssTree->UpdateTreeStatistics();
264
265  cout<<
266        "#RSS_AVG_PVS_SIZE\n"<<rssTree->stat.avgPvsSize<<endl<<
267        "#RSS_AVG_RAYS\n"<<rssTree->stat.avgRays<<endl<<
268        "#RSS_AVG_RAY_CONTRIB\n"<<rssTree->stat.avgRayContribution<<endl<<
269        "#RSS_AVG_PVS_ENTROPY\n"<<rssTree->stat.avgPvsEntropy<<endl<<
270        "#RSS_AVG_RAY_LENGTH_ENTROPY\n"<<rssTree->stat.avgRayLengthEntropy<<endl<<
271        "#RSS_AVG_IMPORTANCE\n"<<rssTree->stat.avgImportance<<endl;
272 
273  if (0) {
274        float p = desiredSamples/(float)(rssTree->stat.avgRayContribution*rssTree->stat.Leaves());
275        num = rssTree->GenerateRays(p, rays);
276  } else {
277        int leaves = rssTree->stat.Leaves()/1;
278        num = rssTree->GenerateRays(desiredSamples, leaves, rays);
279  }
280       
281       
282  return num;
283}
284
285
286bool
287RssPreprocessor::ExportRays(const char *filename,
288                                                        const VssRayContainer &vssRays,
289                                                        const int number
290                                                        )
291{
292  cout<<"Exporting vss rays..."<<endl<<flush;
293       
294  Exporter *exporter = NULL;
295  exporter = Exporter::GetExporter(filename);
296  //    exporter->SetWireframe();
297  //    exporter->ExportKdTree(*mKdTree);
298  exporter->SetFilled();
299  // $$JB temporarily do not export the scene
300  if (1)
301        exporter->ExportScene(mSceneGraph->mRoot);
302  exporter->SetWireframe();
303
304  if (mViewSpaceBox) {
305        exporter->SetForcedMaterial(RgbColor(1,0,1));
306        exporter->ExportBox(*mViewSpaceBox);
307        exporter->ResetForcedMaterial();
308  }
309       
310  VssRayContainer rays;
311 
312  vssRays.SelectRays( number, rays);
313
314  exporter->ExportRays(rays, RgbColor(1, 0, 0));
315       
316  delete exporter;
317
318  cout<<"done."<<endl<<flush;
319
320  return true;
321}
322
323
324bool
325RssPreprocessor::ExportRssTree(char *filename,
326                                                           RssTree *tree,
327                                                           const Vector3 &dir
328                                                           )
329{
330  Exporter *exporter = Exporter::GetExporter(filename);
331  exporter->SetFilled();
332  exporter->ExportScene(mSceneGraph->mRoot);
333  //  exporter->SetWireframe();
334  bool result = exporter->ExportRssTree2( *tree, dir );
335  delete exporter;
336  return result;
337}
338
339bool
340RssPreprocessor::ExportRssTreeLeaf(char *filename,
341                                                                   RssTree *tree,
342                                                                   RssTreeLeaf *leaf)
343{
344  Exporter *exporter = NULL;
345  exporter = Exporter::GetExporter(filename);
346  exporter->SetWireframe();
347  exporter->ExportKdTree(*mKdTree);
348       
349  if (mViewSpaceBox) {
350        exporter->SetForcedMaterial(RgbColor(1,0,0));
351        exporter->ExportBox(*mViewSpaceBox);
352        exporter->ResetForcedMaterial();
353  }
354       
355  exporter->SetForcedMaterial(RgbColor(0,0,1));
356  exporter->ExportBox(tree->GetBBox(leaf));
357  exporter->ResetForcedMaterial();
358       
359  VssRayContainer rays[4];
360  for (int i=0; i < leaf->rays.size(); i++) {
361        int k = leaf->rays[i].GetRayClass();
362        rays[k].push_back(leaf->rays[i].mRay);
363  }
364       
365  // SOURCE RAY
366  exporter->ExportRays(rays[0], RgbColor(1, 0, 0));
367  // TERMINATION RAY
368  exporter->ExportRays(rays[1], RgbColor(1, 1, 1));
369  // PASSING_RAY
370  exporter->ExportRays(rays[2], RgbColor(1, 1, 0));
371  // CONTAINED_RAY
372  exporter->ExportRays(rays[3], RgbColor(0, 0, 1));
373
374  delete exporter;
375  return true;
376}
377
378void
379RssPreprocessor::ExportRssTreeLeaves(RssTree *tree, const int number)
380{
381  vector<RssTreeLeaf *> leaves;
382  tree->CollectLeaves(leaves);
383
384  int num = 0;
385  int i;
386  float p = number / (float)leaves.size();
387  for (i=0; i < leaves.size(); i++) {
388        if (RandomValue(0,1) < p) {
389          char filename[64];
390          sprintf(filename, "rss-leaf-%04d.x3d", num);
391          ExportRssTreeLeaf(filename, tree, leaves[i]);
392          num++;
393        }
394        if (num >= number)
395          break;
396  }
397}
398
399
400float
401RssPreprocessor::GetAvgPvsSize(RssTree *tree,
402                                                           const vector<AxisAlignedBox3> &viewcells
403                                                           )
404{
405  vector<AxisAlignedBox3>::const_iterator it, it_end = viewcells.end();
406
407  int sum = 0;
408  for (it = viewcells.begin(); it != it_end; ++ it)
409        sum += tree->GetPvsSize(*it);
410       
411  return sum/(float)viewcells.size();
412}
413
414
415void
416RssPreprocessor::ExportPvs(char *filename,
417                                                   RssTree *rssTree
418                                                   )
419{
420  ObjectContainer pvs;
421  if (rssTree->CollectRootPvs(pvs)) {
422        Exporter *exporter = Exporter::GetExporter(filename);
423        exporter->SetFilled();
424        exporter->ExportGeometry(pvs);
425        exporter->SetWireframe();
426        exporter->ExportBox(rssTree->bbox);
427        exporter->ExportViewpoint(rssTree->bbox.Center(), Vector3(1,0,0));
428        delete exporter;
429  }
430}
431
432
433void
434RssPreprocessor::ComputeRenderError()
435{
436  // compute rendering error
437  if (renderer) {
438        //      emit EvalPvsStat();
439        //      QMutex mutex;
440        //      mutex.lock();
441        //      renderer->mRenderingFinished.wait(&mutex);
442        //      mutex.unlock();
443
444        renderer->EvalPvsStat();
445        mStats <<
446          "#AvgPvsRenderError\n" <<renderer->mPvsStat.GetAvgError()<<endl<<
447          "#MaxPvsRenderError\n" <<renderer->mPvsStat.GetMaxError()<<endl<<
448          "#ErrorFreeFrames\n" <<renderer->mPvsStat.GetErrorFreeFrames()<<endl<<
449          "#AvgRenderPvs\n" <<renderer->mPvsStat.GetAvgPvs()<<endl;
450  }
451}
452
453
454
455bool
456RssPreprocessor::ComputeVisibility()
457{
458
459        Debug << "type: rss" << endl;
460
461  cout<<"Rss Preprocessor started\n"<<flush;
462  //  cout<<"Memory/ray "<<sizeof(VssRay)+sizeof(RssTreeNode::RayInfo)<<endl;
463
464  Randomize(0);
465 
466       
467  long startTime = GetTime();
468 
469  int totalSamples = 0;
470
471  mViewSpaceBox = NULL;
472
473  // if not already loaded, construct view cells from file
474  if (!mLoadViewCells) {       
475
476        if (0)
477          mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());
478        else {
479          AxisAlignedBox3 box = mKdTree->GetBox();
480          float s = box.Size(0);
481          box.Scale(0.1f);
482          box.SetMin(0, box.Min(0) + s);
483          box.SetMax(0, box.Max(0) + s);
484          mViewCellsManager->SetViewSpaceBox(box);
485        }
486
487          // construct view cells using it's own set of samples
488          mViewCellsManager->Construct(this);
489
490          //-- several visualizations and statistics
491          Debug << "view cells construction finished: " << endl;
492          mViewCellsManager->PrintStatistics(Debug);
493  }
494
495
496  int rssPass = 0;
497  int rssSamples = 0;
498 
499  if (mLoadInitialSamples) {
500        cout << "Loading samples from file ... ";
501        LoadSamples(mVssRays, mObjects);
502        cout << "finished\n" << endl;
503  } else {
504        SimpleRayContainer rays;
505
506        GenerateRays(mInitialSamples/4, SPATIAL_BOX_BASED_DISTRIBUTION, rays);
507        GenerateRays(mInitialSamples/4, OBJECT_BASED_DISTRIBUTION, rays);
508        GenerateRays(mInitialSamples/4, DIRECTION_BASED_DISTRIBUTION, rays);
509        GenerateRays(mInitialSamples/4, OBJECT_DIRECTION_BASED_DISTRIBUTION, rays);
510       
511        CastRays(rays, mVssRays);
512
513        ExportObjectRays(mVssRays, 1546);
514  }
515 
516  cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl <<flush;
517 
518  rssSamples += (int)mVssRays.size();
519  totalSamples += mInitialSamples;
520  mPass++;
521 
522  if (mExportRays) {
523       
524        char filename[64];
525        sprintf(filename, "rss-rays-initial.x3d");
526        ExportRays(filename, mVssRays, mExportNumRays);
527       
528  }
529 
530  if (mStoreInitialSamples) {
531        cout << "Writing samples to file ... ";
532        ExportSamples(mVssRays);
533        cout << "finished\n" << endl;
534  }
535       
536  if (mUseViewcells) {
537
538        // evaluate contributions of the intitial rays
539        mViewCellsManager->ComputeSampleContributions(mVssRays, true, false);
540       
541       
542        mStats <<
543          "#Pass\n" <<mPass<<endl<<
544          "#RssPass\n" <<rssPass<<endl<<
545          "#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<<
546          "#TotalSamples\n" <<totalSamples<<endl<<
547          "#RssSamples\n" <<rssSamples<<endl;
548
549        {
550          VssRayContainer contributingRays;
551          mVssRays.GetContributingRays(contributingRays, mPass);
552          mStats<<"#NUM_CONTRIBUTING_RAYS\n"<<(int)contributingRays.size()<<endl;
553        }
554       
555        mVssRays.PrintStatistics(mStats);
556        mViewCellsManager->PrintPvsStatistics(mStats);
557         
558        // viewcells->UpdatePVS(newVssRays);
559        Debug<<"Valid viewcells before set validity: "<<mViewCellsManager->CountValidViewcells()<<endl;
560        // cull viewcells with PVS > median (0.5f)
561        //      mViewCellsManager->SetValidityPercentage(0, 0.5f);
562        Debug<<"Valid viewcells after set validity: "<<mViewCellsManager->CountValidViewcells()<<endl;
563       
564        ComputeRenderError();
565  }
566 
567  rssPass++;
568 
569  mRssTree = new RssTree;
570  mRssTree->SetPass(mPass);
571 
572  /// compute view cell contribution of rays if view cells manager already constructed
573  mViewCellsManager->ComputeSampleContributions(mVssRays, true, false);
574
575  if (mUseImportanceSampling) {
576       
577        mRssTree->Construct(mObjects, mVssRays);
578       
579        mRssTree->stat.Print(mStats);
580        cout<<"RssTree root PVS size = "<<mRssTree->GetRootPvsSize()<<endl;
581       
582        if (mExportRssTree) {
583          ExportRssTree("rss-tree-100.x3d", mRssTree, Vector3(1,0,0));
584          ExportRssTree("rss-tree-001.x3d", mRssTree, Vector3(0,0,1));
585          ExportRssTree("rss-tree-101.x3d", mRssTree, Vector3(1,0,1));
586          ExportRssTree("rss-tree-101m.x3d", mRssTree, Vector3(-1,0,-1));
587          ExportRssTreeLeaves(mRssTree, 10);
588        }
589       
590        if (mExportPvs) {
591          ExportPvs("rss-pvs-initial.x3d", mRssTree);
592        }
593  }
594 
595 
596  while (1) {
597        SimpleRayContainer rays;
598        VssRayContainer vssRays;
599        int castRays = 0;
600        if (mUseImportanceSampling) {
601          VssRayContainer tmpVssRays;
602
603          float ratios[] = {0.8f,0.1f,0.1f};
604
605          GenerateRays(mRssSamplesPerPass*ratios[0], RSS_BASED_DISTRIBUTION, rays);
606          CastRays(rays, tmpVssRays);
607          castRays += rays.size();
608          float c1 = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
609          mStats<<"#RssRelContrib"<<endl<<c1/rays.size()<<endl;
610
611          vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
612          rays.clear();
613          tmpVssRays.clear();
614
615          if (ratios[1]!=0.0f) {
616                GenerateRays(mRssSamplesPerPass*ratios[1], SPATIAL_BOX_BASED_DISTRIBUTION, rays);
617                CastRays(rays, tmpVssRays);
618                castRays += rays.size();
619                float c2 = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
620                mStats<<"#SpatialRelContrib"<<endl<<c2/rays.size()<<endl;
621               
622                vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
623               
624                rays.clear();
625                tmpVssRays.clear();
626          }
627         
628         
629          if (ratios[2]!=0.0f) {
630                GenerateRays(mRssSamplesPerPass*ratios[2], DIRECTION_BASED_DISTRIBUTION, rays);
631                CastRays(rays, tmpVssRays);
632                castRays += rays.size();
633                float c3 = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
634                mStats<<"#DirectionalRelContrib"<<endl<<c3/rays.size()<<endl;
635               
636                vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
637               
638                rays.clear();
639                tmpVssRays.clear();
640          }
641         
642          // add contributions of all rays at once...
643          mViewCellsManager->AddSampleContributions(vssRays);
644         
645        }
646        else {
647          int rayType = SPATIAL_BOX_BASED_DISTRIBUTION;
648          if (mObjectBasedSampling)
649                rayType = OBJECT_BASED_DISTRIBUTION;
650          else
651                if (mDirectionalSampling)
652                  rayType = DIRECTION_BASED_DISTRIBUTION;
653         
654          GenerateRays(mRssSamplesPerPass, rayType, rays);
655          CastRays(rays, vssRays);
656          castRays += rays.size();
657          if (mUseViewcells) {
658                /// compute view cell contribution of rays
659                mViewCellsManager->ComputeSampleContributions(vssRays, true, false);
660          }
661               
662         
663        }
664        totalSamples += castRays;
665        rssSamples += (int)vssRays.size();
666
667        cout<<"Generated "<<castRays<<" rays, progress "<<totalSamples/((float) mRssSamples +
668                                                                                                                                        mInitialSamples)<<"%\n";
669       
670       
671        mStats <<
672          "#Pass\n" <<mPass<<endl<<
673          "#RssPass\n" <<rssPass<<endl<<
674          "#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<<
675          "#TotalSamples\n" <<totalSamples<<endl<<
676          "#RssSamples\n" <<rssSamples<<endl;
677
678
679        if (mUseViewcells) {
680          vssRays.PrintStatistics(mStats);
681          mViewCellsManager->PrintPvsStatistics(mStats);
682        }
683
684        if (0 && mPass > 0) {
685          if (mUseImportanceSampling)
686                renderer->mSnapPrefix.sprintf("snap/i-%02d-", mPass);
687          else
688                renderer->mSnapPrefix.sprintf("snap/r-%02d-", mPass);
689          renderer->mSnapErrorFrames = true;
690        }
691
692        ComputeRenderError();
693       
694        // epxort rays before adding them to the tree -> some of them can be deleted
695
696        if (mExportRays) {
697          char filename[64];
698          if (mUseImportanceSampling)
699                sprintf(filename, "rss-rays-i%04d.x3d", rssPass);
700          else
701                sprintf(filename, "rss-rays-%04d.x3d", rssPass);
702         
703          ExportRays(filename, vssRays, mExportNumRays);
704
705          // now export all contributing rays
706          VssRayContainer contributingRays;
707          vssRays.GetContributingRays(contributingRays, mPass);
708          mStats<<"#NUM_CONTRIBUTING_RAYS\n"<<(int)contributingRays.size()<<endl;
709          sprintf(filename, "rss-crays-%04d.x3d", rssPass);
710          ExportRays(filename, contributingRays, mExportNumRays);
711        }
712
713       
714        // add rays to the tree after the viewcells have been cast to have their contributions
715        // already when adding into the tree
716        // do not add those rays which have too low or no contribution....
717       
718        if (mUseImportanceSampling) {
719          mRssTree->AddRays(vssRays);
720         
721          if (mUpdateSubdivision) {
722                int updatePasses = 1;
723                if (mPass % updatePasses == 0) {
724                  int subdivided = mRssTree->UpdateSubdivision();
725                  cout<<"subdivided leafs = "<<subdivided<<endl;
726                  cout<<"#total leaves = "<<mRssTree->stat.Leaves()<<endl;
727                }
728          }
729        }
730       
731        if (mExportPvs) {
732          char filename[64];
733          sprintf(filename, "rss-pvs-%04d.x3d", rssPass);
734          ExportPvs(filename, mRssTree);
735        }
736       
737       
738        if (!mUseImportanceSampling)
739          CLEAR_CONTAINER(vssRays);
740        // otherwise the rays get deleted by the rss tree update according to RssTree.maxRays ....
741
742        if (totalSamples >= mRssSamples + mInitialSamples)
743          break;
744
745       
746        rssPass++;
747        mPass++;
748        mRssTree->SetPass(mPass);
749  }
750 
751  if (mUseViewcells) {
752
753          if(0)
754          {
755                  VssRayContainer selectedRays;
756                  int desired = mViewCellsManager->GetVisualizationSamples();
757
758                  mVssRays.SelectRays(desired, selectedRays);
759
760                  mViewCellsManager->Visualize(mObjects, selectedRays);
761          }
762         
763          // view cells after sampling
764          mViewCellsManager->PrintStatistics(Debug);
765     
766          //-- render simulation after merge
767          cout << "\nevaluating bsp view cells render time after sampling ... ";
768         
769          mRenderSimulator->RenderScene();
770          SimulationStatistics ss;
771          mRenderSimulator->GetStatistics(ss);
772         
773          cout << " finished" << endl;
774          cout << ss << endl;
775          Debug << ss << endl;
776       
777  }
778 
779  Debug<<"Deleting RSS tree...\n";
780  delete mRssTree;
781  Debug<<"Done.\n";
782
783 
784  return true;
785}
786
Note: See TracBrowser for help on using the repository browser.