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

Revision 1281, 24.2 KB checked in by bittner, 18 years ago (diff)

mlrt 16 ray tracing support
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 
506  int totalSamples = 0;
507
508  mViewSpaceBox = NULL;
509
510  // if not already loaded, construct view cells from file
511  if (!mLoadViewCells)
512  {
513        if (1)
514          mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());
515        else {
516          AxisAlignedBox3 box = mKdTree->GetBox();
517         
518          if (1) {
519                // use a small box outside of the scene
520                box.Scale(Vector3(0.1f,0.5f,0.5f));
521                box.Translate(Vector3(Magnitude(mKdTree->GetBox().Size())*0.5, 0, 0));
522          } else {
523                float s = box.Size(0);
524                box.Scale(0.1f);
525                box.SetMin(0, box.Min(0) + s);
526                box.SetMax(0, box.Max(0) + s);
527          }
528         
529          mViewCellsManager->SetViewSpaceBox(box);
530        }
531       
532        // construct view cells using it's own set of samples
533        mViewCellsManager->Construct(this);
534       
535        //-- several visualizations and statistics
536        Debug << "view cells construction finished: " << endl;
537        mViewCellsManager->PrintStatistics(Debug);
538  }
539 
540 
541  int rssPass = 0;
542  int rssSamples = 0;
543 
544  if (mLoadInitialSamples) {
545        cout << "Loading samples from file ... ";
546        LoadSamples(mVssRays, mObjects);
547        cout << "finished\n" << endl;
548  } else {
549        SimpleRayContainer rays;
550
551        cout<<"Generating initial rays..."<<endl<<flush;
552
553        if (mUseImportanceSampling) {
554          GenerateRays(mInitialSamples/3, SPATIAL_BOX_BASED_DISTRIBUTION, rays);
555          GenerateRays(mInitialSamples/3, OBJECT_BASED_DISTRIBUTION, rays);
556          GenerateRays(mInitialSamples/3, DIRECTION_BASED_DISTRIBUTION, rays);
557          //    GenerateRays(mInitialSamples/4, OBJECT_DIRECTION_BASED_DISTRIBUTION, rays);
558        } else {
559          int rayType = SPATIAL_BOX_BASED_DISTRIBUTION;
560          if (mObjectBasedSampling)
561                rayType = OBJECT_BASED_DISTRIBUTION;
562          else
563                if (mDirectionalSampling)
564                  rayType = DIRECTION_BASED_DISTRIBUTION;
565          cout<<"Generating rays..."<<endl;
566          GenerateRays(mRssSamplesPerPass, rayType, rays);
567        }
568       
569       
570        cout<<"Casting initial rays..."<<endl<<flush;
571        CastRays(rays, mVssRays);
572
573        ExportObjectRays(mVssRays, 1546);
574  }
575 
576  cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl <<flush;
577 
578  rssSamples += (int)mVssRays.size();
579  totalSamples += mInitialSamples;
580  mPass++;
581 
582  if (mExportRays) {
583       
584        char filename[64];
585        sprintf(filename, "rss-rays-initial.x3d");
586        ExportRays(filename, mVssRays, mExportNumRays);
587
588        mVssRays.SelectRays(mExportNumRays, rayBuffer[0], true);
589       
590  }
591 
592  if (mStoreInitialSamples) {
593        cout << "Writing samples to file ... ";
594        ExportSamples(mVssRays);
595        cout << "finished\n" << endl;
596  }
597       
598  if (mUseViewcells) {
599
600        cout<<"Computing sample contributions..."<<endl<<flush;
601        // evaluate contributions of the intitial rays
602        mViewCellsManager->ComputeSampleContributions(mVssRays, true, false);
603        cout<<"done.\n"<<flush;
604       
605        mStats <<
606          "#Pass\n" <<mPass<<endl<<
607          "#RssPass\n" <<rssPass<<endl<<
608          "#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<<
609          "#TotalSamples\n" <<totalSamples<<endl<<
610          "#RssSamples\n" <<rssSamples<<endl;
611
612        {
613          VssRayContainer contributingRays;
614          mVssRays.GetContributingRays(contributingRays, 0);
615          mStats<<"#NUM_CONTRIBUTING_RAYS\n"<<(int)contributingRays.size()<<endl;
616          if (mExportRays) {
617                char filename[64];
618                sprintf(filename, "rss-crays-%04d.x3d", 0);
619                ExportRays(filename, contributingRays, mExportNumRays);
620          }
621        }
622       
623        mVssRays.PrintStatistics(mStats);
624        mViewCellsManager->PrintPvsStatistics(mStats);
625         
626        // viewcells->UpdatePVS(newVssRays);
627        Debug<<"Valid viewcells before set validity: "<<mViewCellsManager->CountValidViewcells()<<endl;
628        // cull viewcells with PVS > median (0.5f)
629        //mViewCellsManager->SetValidityPercentage(0, 0.5f);
630        mViewCellsManager->SetValidityPercentage(0, 1.0f);
631        Debug<<"Valid viewcells after set validity: "<<mViewCellsManager->CountValidViewcells()<<endl;
632       
633        ComputeRenderError();
634  }
635 
636  rssPass++;
637 
638  mRssTree = new RssTree;
639  mRssTree->SetPass(mPass);
640 
641  /// compute view cell contribution of rays if view cells manager already constructed
642  //  mViewCellsManager->ComputeSampleContributions(mVssRays, true, false);
643
644  if (mUseImportanceSampling) {
645       
646        mRssTree->Construct(mObjects, mVssRays);
647       
648        mRssTree->stat.Print(mStats);
649        cout<<"RssTree root PVS size = "<<mRssTree->GetRootPvsSize()<<endl;
650       
651        if (mExportRssTree) {
652          ExportRssTree("rss-tree-100.x3d", mRssTree, Vector3(1,0,0));
653          ExportRssTree("rss-tree-001.x3d", mRssTree, Vector3(0,0,1));
654          ExportRssTree("rss-tree-101.x3d", mRssTree, Vector3(1,0,1));
655          ExportRssTree("rss-tree-101m.x3d", mRssTree, Vector3(-1,0,-1));
656          ExportRssTreeLeaves(mRssTree, 10);
657        }
658       
659        if (mExportPvs) {
660          ExportPvs("rss-pvs-initial.x3d", mRssTree);
661        }
662  }
663 
664 
665  while (1) {
666        SimpleRayContainer rays;
667        VssRayContainer vssRays;
668        int castRays = 0;
669        if (mUseImportanceSampling) {
670          VssRayContainer tmpVssRays;
671
672          static float ratios[] = {0.9f,0.05f,0.05f};
673          //float ratios[] = {1.0f,0.0f,0.0f};
674         
675          int nrays[3];
676          float contributions[3];
677          float times[3];
678         
679          long t1;
680
681          t1 = GetTime();
682         
683          GenerateRays(mRssSamplesPerPass*ratios[0], RSS_BASED_DISTRIBUTION, rays);
684
685          rays.NormalizePdf((int)rays.size());
686         
687          CastRays(rays, tmpVssRays);
688          castRays += rays.size();
689#if ADD_RAYS_IN_PLACE
690          contributions[0] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, true, false);
691#else
692          contributions[0] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
693#endif
694          times[0] = TimeDiff(t1, GetTime());
695          nrays[0] = rays.size();
696         
697          mStats<<"#RssRelContrib"<<endl<<contributions[0]/nrays[0]<<endl;
698         
699          vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
700          rays.clear();
701          tmpVssRays.clear();
702          if (ratios[1]!=0.0f) {
703                t1 = GetTime();
704                GenerateRays(mRssSamplesPerPass*ratios[1], SPATIAL_BOX_BASED_DISTRIBUTION, rays);
705                CastRays(rays, tmpVssRays);
706                castRays += rays.size();
707#if ADD_RAYS_IN_PLACE
708                contributions[1] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, true, false);
709#else
710                contributions[1] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
711#endif
712          times[1] = TimeDiff(t1, GetTime());
713          nrays[1] = rays.size();
714
715          mStats<<"#SpatialRelContrib"<<endl<<contributions[1]/nrays[1]<<endl;
716               
717                vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
718               
719                rays.clear();
720                tmpVssRays.clear();
721          }
722         
723         
724          if (ratios[2]!=0.0f) {
725                t1 = GetTime();
726                GenerateRays(mRssSamplesPerPass*ratios[2], DIRECTION_BASED_DISTRIBUTION, rays);
727                CastRays(rays, tmpVssRays);
728                castRays += rays.size();
729#if ADD_RAYS_IN_PLACE
730                contributions[2] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, true, false);
731#else
732                contributions[2] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
733#endif
734                times[2] = TimeDiff(t1, GetTime());
735                nrays[2] = rays.size();
736               
737                mStats<<"#DirectionalRelContrib"<<endl<<contributions[2]/nrays[2]<<endl;
738               
739                vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
740               
741                rays.clear();
742                tmpVssRays.clear();
743          }
744         
745         
746          // now evaluate the ratios for the next pass
747#define TIMES 0
748
749#if TIMES
750          ratios[0] = sqr(contributions[0]/times[0]);
751          ratios[1] = sqr(contributions[1]/times[1]);
752          ratios[2] = sqr(contributions[2]/times[2]);
753#else
754          ratios[0] = sqr(contributions[0]/nrays[0]);
755          ratios[1] = sqr(contributions[1]/nrays[1]);
756          ratios[2] = sqr(contributions[2]/nrays[2]);
757#endif
758          NormalizeRatios(ratios);
759
760          cout<<"New ratios: "<<ratios[0]<<" "<<ratios[1]<<" "<<ratios[2]<<endl;
761         
762          // add contributions of all rays at once...
763#if !ADD_RAYS_IN_PLACE
764          mViewCellsManager->AddSampleContributions(vssRays);
765#endif   
766        }
767        else {
768          int rayType = SPATIAL_BOX_BASED_DISTRIBUTION;
769          if (mObjectBasedSampling)
770                rayType = OBJECT_BASED_DISTRIBUTION;
771          else
772                if (mDirectionalSampling)
773                  rayType = DIRECTION_BASED_DISTRIBUTION;
774
775          cout<<"Generating rays..."<<endl;
776
777          GenerateRays(mRssSamplesPerPass, rayType, rays);
778          cout<<"done."<<endl;
779
780          cout<<"Casting rays..."<<endl;
781          CastRays(rays, vssRays);
782          cout<<"done."<<endl;
783          castRays += rays.size();
784          if (mUseViewcells) {
785                /// compute view cell contribution of rays
786                cout<<"Computing sample contributions..."<<endl;
787                mViewCellsManager->ComputeSampleContributions(vssRays, true, false);
788                cout<<"done."<<endl;
789          }
790               
791         
792        }
793        totalSamples += castRays;
794        rssSamples += (int)vssRays.size();
795
796        cout<<"Generated "<<castRays<<" rays, progress "<<100.0f*totalSamples/((float) mRssSamples +
797                                                                                                                                                   mInitialSamples)<<"%\n";
798       
799       
800        mStats <<
801          "#Pass\n" <<mPass<<endl<<
802          "#RssPass\n" <<rssPass<<endl<<
803          "#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<<
804          "#TotalSamples\n" <<totalSamples<<endl<<
805          "#RssSamples\n" <<rssSamples<<endl;
806
807
808        if (mUseViewcells) {
809          vssRays.PrintStatistics(mStats);
810          mViewCellsManager->PrintPvsStatistics(mStats);
811        }
812
813        if (0 && mPass > 0) {
814                char buf[100];
815          if (mUseImportanceSampling)
816          {
817                sprintf(buf, "snap/i-%02d-", mPass);
818
819                renderer->SetSnapPrefix(buf);
820          }
821          else
822          {
823                sprintf(buf, "snap/r-%02d-", mPass);
824
825                renderer->SetSnapPrefix(buf);
826          }
827
828          renderer->SetSnapErrorFrames(true);
829        }
830
831        ComputeRenderError();
832       
833        // epxort rays before adding them to the tree -> some of them can be deleted
834
835        if (mExportRays) {
836          char filename[64];
837          if (mUseImportanceSampling)
838                sprintf(filename, "rss-rays-i%04d.x3d", rssPass);
839          else
840                sprintf(filename, "rss-rays-%04d.x3d", rssPass);
841         
842         
843
844          vssRays.SelectRays(mExportNumRays, rayBuffer[mPass], true);
845         
846          ExportRays(filename, vssRays, mExportNumRays);
847         
848          // now export all contributing rays
849          VssRayContainer contributingRays;
850          vssRays.GetContributingRays(contributingRays, mPass);
851          mStats<<"#NUM_CONTRIBUTING_RAYS\n"<<(int)contributingRays.size()<<endl;
852          sprintf(filename, "rss-crays-%04d.x3d", rssPass);
853          ExportRays(filename, contributingRays, mExportNumRays);
854         
855        }
856
857       
858        // add rays to the tree after the viewcells have been cast to have their contributions
859        // already when adding into the tree
860        // do not add those rays which have too low or no contribution....
861       
862        if (mUseImportanceSampling) {
863          mRssTree->AddRays(vssRays);
864         
865          if (mUpdateSubdivision) {
866                int updatePasses = 1;
867                if (mPass % updatePasses == 0) {
868                  int subdivided = mRssTree->UpdateSubdivision();
869                  cout<<"subdivided leafs = "<<subdivided<<endl;
870                  cout<<"#total leaves = "<<mRssTree->stat.Leaves()<<endl;
871                }
872          }
873        }
874       
875        if (mExportPvs) {
876          char filename[64];
877          sprintf(filename, "rss-pvs-%04d.x3d", rssPass);
878          ExportPvs(filename, mRssTree);
879        }
880       
881       
882        if (!mUseImportanceSampling)
883          CLEAR_CONTAINER(vssRays);
884        // otherwise the rays get deleted by the rss tree update according to RssTree.maxRays ....
885
886        if (totalSamples >= mRssSamples + mInitialSamples)
887          break;
888
889       
890        rssPass++;
891        mPass++;
892        mRssTree->SetPass(mPass);
893  }
894 
895  if (mUseViewcells) {
896
897        if(0)
898          {
899                VssRayContainer selectedRays;
900                int desired = mViewCellsManager->GetVisualizationSamples();
901               
902                mVssRays.SelectRays(desired, selectedRays);
903               
904                mViewCellsManager->Visualize(mObjects, selectedRays);
905          }
906       
907        // view cells after sampling
908        mViewCellsManager->PrintStatistics(Debug);
909       
910        //-- render simulation after merge
911        cout << "\nevaluating bsp view cells render time after sampling ... ";
912       
913        mRenderSimulator->RenderScene();
914        SimulationStatistics ss;
915        mRenderSimulator->GetStatistics(ss);
916       
917        cout << " finished" << endl;
918        cout << ss << endl;
919        Debug << ss << endl;
920       
921  }
922
923
924  if (mExportRays && mUseImportanceSampling) {
925        char filename[64];
926        sprintf(filename, "rss-rays-i.x3d");
927       
928        rayBuffer.resize(mPass);
929        ExportRayAnimation(filename, rayBuffer);
930  }
931         
932  Debug<<"Deleting RSS tree...\n";
933  delete mRssTree;
934  Debug<<"Done.\n";
935
936
937  //mViewCellsManager->ExportViewCells("visibility.xml",
938  //                                                                     true);
939 
940 
941  return true;
942}
943
944}
Note: See TracBrowser for help on using the repository browser.