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

Revision 1299, 24.4 KB checked in by bittner, 18 years ago (diff)

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