source: trunk/VUT/GtpVisibilityPreprocessor/src/VssPreprocessor.cpp @ 540

Revision 540, 20.2 KB checked in by mattausch, 19 years ago (diff)
Line 
1#include "SceneGraph.h"
2#include "KdTree.h"
3#include "VssPreprocessor.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 "VssTree.h"
11#include "ViewCellsManager.h"
12#include "RenderSimulator.h"
13#include "Beam.h"
14#include "GlRenderer.h"
15
16bool use2dSampling = false;
17bool useViewspacePlane = false;
18
19VssPreprocessor::VssPreprocessor():
20  mPass(0),
21  mVssRays()
22{
23  // this should increase coherence of the samples
24  environment->GetIntValue("VssPreprocessor.samplesPerPass", mSamplesPerPass);
25  environment->GetIntValue("VssPreprocessor.initialSamples", mInitialSamples);
26  environment->GetIntValue("VssPreprocessor.vssSamples", mVssSamples);
27  environment->GetIntValue("VssPreprocessor.vssSamplesPerPass", mVssSamplesPerPass);
28  environment->GetBoolValue("VssPreprocessor.useImportanceSampling", mUseImportanceSampling);
29  environment->GetBoolValue("ViewCells.delayedConstruction", mDelayedViewCellsConstruction);
30
31  environment->GetBoolValue("VssPreprocessor.loadInitialSamples", mLoadInitialSamples);
32  environment->GetBoolValue("VssPreprocessor.storeInitialSamples", mStoreInitialSamples);
33  environment->GetBoolValue("VssPreprocessor.useViewSpaceBox", mUseViewSpaceBox);
34  environment->GetBoolValue("VssPreprocessor.testBeamSampling", mTestBeamSampling);
35
36  useViewspacePlane = mUseViewSpaceBox; //hack
37
38  mStats.open("stats.log");
39}
40
41VssPreprocessor::~VssPreprocessor()
42{
43  CLEAR_CONTAINER(mVssRays);
44}
45
46void
47VssPreprocessor::SetupRay(Ray &ray,
48                                                  const Vector3 &point,
49                                                  const Vector3 &direction
50                                                  )
51{
52  ray.Clear();
53  // do not store anything else then intersections at the ray
54  ray.Init(point, direction, Ray::LOCAL_RAY);
55}
56
57int
58VssPreprocessor::CastRay(
59                                                 Vector3 &viewPoint,
60                                                 Vector3 &direction,
61                                                 VssRayContainer &vssRays
62                                                 )
63{
64
65    int hits = 0;
66  static Ray ray;
67  AxisAlignedBox3 box = mKdTree->GetBox();
68
69  AxisAlignedBox3 sbox = box;
70  sbox.Enlarge(Vector3(-Limits::Small));
71  if (!sbox.IsInside(viewPoint))
72        return 0;
73       
74  SetupRay(ray, viewPoint, direction);
75  // cast ray to KD tree to find intersection with other objects
76  Intersectable *objectA, *objectB;
77  Vector3 pointA, pointB;
78  float bsize = Magnitude(box.Size());
79
80
81  if (!mDetectEmptyViewSpace)
82        ray.mFlags &= ~Ray::CULL_BACKFACES;
83 
84  if (mKdTree->CastRay(ray)) {
85        objectA = ray.intersections[0].mObject;
86        pointA = ray.Extrap(ray.intersections[0].mT);
87  } else {
88        objectA = NULL;
89        // compute intersection with the scene bounding box
90        float tmin, tmax;
91        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
92          pointA = ray.Extrap(tmax);
93        else
94          return 0;
95  }
96
97       
98  if (mDetectEmptyViewSpace) {
99        SetupRay(ray, pointA, -direction);
100  } else
101        SetupRay(ray, viewPoint, -direction);
102 
103  if (!mDetectEmptyViewSpace)
104        ray.mFlags &= ~Ray::CULL_BACKFACES;
105
106  if (mKdTree->CastRay(ray)) {
107        objectB = ray.intersections[0].mObject;
108        pointB = ray.Extrap(ray.intersections[0].mT);
109  } else {
110        objectB = NULL;
111        float tmin, tmax;
112        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
113          pointB = ray.Extrap(tmax);
114        else
115          return 0;
116  }
117 
118  //  if (objectA == NULL && objectB != NULL) {
119  if (mDetectEmptyViewSpace) {
120        // cast again to ensure that there is no objectA
121        SetupRay(ray, pointB, direction);
122        if (mKdTree->CastRay(ray)) {
123          objectA = ray.intersections[0].mObject;
124          pointA = ray.Extrap(ray.intersections[0].mT);
125        }
126  }
127
128 
129  VssRay *vssRay  = NULL;
130
131  bool validSample = (objectA != objectB);
132  if (0 && mDetectEmptyViewSpace) {   // consider all samples valid
133        // check if the viewpoint lies on the line segment AB
134        if (Distance(pointA, pointB) <
135                Distance(viewPoint, pointA) + Distance(viewPoint, pointB) - Limits::Small) {
136          validSample = false;
137        }
138  }
139       
140  if (validSample) {
141        if (objectA) {
142          vssRay = new VssRay(pointB,
143                                                  pointA,
144                                                  objectB,
145                                                  objectA,
146                                                  mPass
147                                                  );
148          vssRays.push_back(vssRay);
149          hits ++;
150        }
151       
152        if (objectB) {
153          vssRay = new VssRay(pointA,
154                                                  pointB,
155                                                  objectA,
156                                                  objectB,
157                                                  mPass
158                                                  );
159          vssRays.push_back(vssRay);
160          hits ++;
161        }
162  }
163       
164  return hits;
165}
166
167
168Vector3
169VssPreprocessor::GetViewpoint(AxisAlignedBox3 *viewSpaceBox)
170{
171  AxisAlignedBox3 box;
172
173  if (viewSpaceBox)
174        box =*viewSpaceBox;
175  else
176        box = mKdTree->GetBox();
177
178  // shrink the box in the y direction
179  return box.GetRandomPoint();
180}
181
182Vector3
183VssPreprocessor::GetDirection(const Vector3 &viewpoint,
184                                                          AxisAlignedBox3 *viewSpaceBox
185                                                          )
186{
187  Vector3 point;
188  if (!use2dSampling) {
189        if (0) {
190          Vector3 normal;
191          int i = Random((int)mObjects.size());
192          Intersectable *object = mObjects[i];
193          object->GetRandomSurfacePoint(point, normal);
194        } else
195          point = mKdTree->GetBox().GetRandomPoint();
196        //        point = viewpoint + UniformRandomVector();
197
198  } else {
199        AxisAlignedBox3 box;
200
201        if (viewSpaceBox)
202          box =*viewSpaceBox;
203        else
204          box = mKdTree->GetBox();
205
206        point = box.GetRandomPoint();
207        point.y = viewpoint.y;
208  }
209
210  return point - viewpoint;
211}
212
213int
214VssPreprocessor::GenerateImportanceRays(VssTree *vssTree,
215                                                                                const int desiredSamples,
216                                                                                SimpleRayContainer &rays
217                                                                                )
218{
219  int num;
220  if (0) {
221        float minRayContribution;
222        float maxRayContribution;
223        float avgRayContribution;
224
225        vssTree->GetRayContributionStatistics(minRayContribution,
226                                                                                  maxRayContribution,
227                                                                                  avgRayContribution);
228
229        cout<<
230          "#MIN_RAY_CONTRIB\n"<<minRayContribution<<endl<<
231          "#MAX_RAY_CONTRIB\n"<<maxRayContribution<<endl<<
232          "#AVG_RAY_CONTRIB\n"<<avgRayContribution<<endl;
233
234        float p = desiredSamples/(float)(avgRayContribution*vssTree->stat.Leaves());
235        num = vssTree->GenerateRays(p, rays);
236  } else {
237        int leaves = vssTree->stat.Leaves();
238        num = vssTree->GenerateRays(desiredSamples, leaves, rays);
239  }
240
241  cout<<"Generated "<<num<<" rays."<<endl;
242
243  return num;
244}
245
246
247bool
248VssPreprocessor::ExportRays(const char *filename,
249                                                        const VssRayContainer &vssRays,
250                                                        const int number
251                                                        )
252{
253  cout<<"Exporting vss rays..."<<endl<<flush;
254
255  Exporter *exporter = NULL;
256  exporter = Exporter::GetExporter(filename);
257  //    exporter->SetWireframe();
258  //    exporter->ExportKdTree(*mKdTree);
259  exporter->SetFilled();
260  exporter->ExportScene(mSceneGraph->mRoot);
261  exporter->SetWireframe();
262
263  if (mViewSpaceBox) {
264        exporter->SetForcedMaterial(RgbColor(1,0,1));
265        exporter->ExportBox(*mViewSpaceBox);
266        exporter->ResetForcedMaterial();
267  }
268
269  VssRayContainer rays;
270  vssRays.SelectRays(number, rays);
271 
272  exporter->ExportRays(rays, RgbColor(1, 0, 0));
273
274  delete exporter;
275
276  cout<<"done."<<endl<<flush;
277
278  return true;
279}
280
281
282bool
283VssPreprocessor::ExportVssTree(char *filename,
284                                                           VssTree *tree,
285                                                           const Vector3 &dir
286                                                           )
287{
288  Exporter *exporter = Exporter::GetExporter(filename);
289  exporter->SetFilled();
290  exporter->ExportScene(mSceneGraph->mRoot);
291  //  exporter->SetWireframe();
292  bool result = exporter->ExportVssTree2( *tree, dir );
293  delete exporter;
294  return result;
295}
296
297bool
298VssPreprocessor::ExportVssTreeLeaf(char *filename,
299                                                                   VssTree *tree,
300                                                                   VssTreeLeaf *leaf)
301{
302  Exporter *exporter = NULL;
303  exporter = Exporter::GetExporter(filename);
304  exporter->SetWireframe();
305  exporter->ExportKdTree(*mKdTree);
306
307  if (mViewSpaceBox) {
308        exporter->SetForcedMaterial(RgbColor(1,0,0));
309        exporter->ExportBox(*mViewSpaceBox);
310        exporter->ResetForcedMaterial();
311  }
312
313  exporter->SetForcedMaterial(RgbColor(0,0,1));
314  exporter->ExportBox(tree->GetBBox(leaf));
315  exporter->ResetForcedMaterial();
316
317  VssRayContainer rays[4];
318  for (int i=0; i < leaf->rays.size(); i++) {
319        int k = leaf->rays[i].GetRayClass();
320        rays[k].push_back(leaf->rays[i].mRay);
321  }
322
323  // SOURCE RAY
324  exporter->ExportRays(rays[0], RgbColor(1, 0, 0));
325  // TERMINATION RAY
326  exporter->ExportRays(rays[1], RgbColor(1, 1, 1));
327  // PASSING_RAY
328  exporter->ExportRays(rays[2], RgbColor(1, 1, 0));
329  // CONTAINED_RAY
330  exporter->ExportRays(rays[3], RgbColor(0, 0, 1));
331
332  delete exporter;
333  return true;
334}
335
336void
337VssPreprocessor::ExportVssTreeLeaves(VssTree *tree, const int number)
338{
339  vector<VssTreeLeaf *> leaves;
340  tree->CollectLeaves(leaves);
341
342  int num = 0;
343  int i;
344  float p = number / (float)leaves.size();
345  for (i=0; i < leaves.size(); i++) {
346        if (RandomValue(0,1) < p) {
347          char filename[64];
348          sprintf(filename, "vss-leaf-%04d.x3d", num);
349          ExportVssTreeLeaf(filename, tree, leaves[i]);
350          num++;
351        }
352        if (num >= number)
353          break;
354  }
355}
356#include "ViewCellBsp.h"
357
358void VssPreprocessor::TestBeamCasting(VssTree *tree,
359                                                                          ViewCellsManager *vm,
360                                                                          const ObjectContainer &objects)
361{
362        //debuggerWidget = new GlDebuggerWidget(renderer);
363        //  renderer->resize(640, 480);
364        //debuggerWidget->resize(640, 480);
365
366        vector<VssTreeLeaf *> leaves;
367        tree->CollectLeaves(leaves);
368
369        Exporter *exporter = Exporter::GetExporter("shafts.x3d");
370
371        exporter->SetWireframe();
372        exporter->ExportGeometry(objects);
373        exporter->SetFilled();
374        //Randomize();
375        debuggerWidget = new GlDebuggerWidget(renderer);
376
377        /*debuggerWidget->mBeam = beam;
378        debuggerWidget->mSourceObject = sourceObj;
379        debuggerWidget->mSamples = 10000;
380       
381        Debug << "showing window" << endl;
382        debuggerWidget->show();*/
383       
384        renderer->makeCurrent();
385
386        for (int i = 0; i < 10; ++ i)
387        {
388                Beam beam;
389                Intersectable *sourceObj = mObjects[5];
390
391                const int index = (int)RandomValue(0, (Real)((int)leaves.size() - 1));
392                VssTreeLeaf *leaf = leaves[index];
393
394                AxisAlignedBox3 dirBox = tree->GetDirBBox(leaf);
395                AxisAlignedBox3 box = tree->GetBBox(leaf);
396               
397                beam.Construct(box, dirBox);
398
399                // collect kd leaves and view cells
400                mKdTree->CastBeam(beam);
401                vm->CastBeam(beam);
402
403                Debug << "found " << beam.mViewCells.size() << " view cells and "
404                          << beam.mKdNodes.size() << " kd nodes" << endl;
405
406                BeamSampleStatistics stats;
407
408                renderer->SampleBeamContributions(sourceObj,
409                                                                                  beam,
410                                                                                  200000,
411                                                                                  stats);
412
413                char s[64]; sprintf(s, "shaft%04d.png", i);
414
415                QImage image = renderer->toImage();
416                image.save(s, "PNG");
417                Debug << "beam statistics: " << stats << endl << endl;
418
419                if (1)
420                {
421                        AxisAlignedBox3 sbox = mSceneGraph->GetBox();
422                        Vector3 bmin = sbox.Min() - 150.0f;
423                        Vector3 bmax = sbox.Max() + 150.0f;
424                        AxisAlignedBox3 vbox(bmin, bmax);
425               
426                        exporter->ExportBeam(beam, vbox);
427                }
428
429                bool exportViewCells = false;
430               
431                if (exportViewCells)
432                {
433                        ViewCellContainer::const_iterator it, it_end = beam.mViewCells.end();
434                       
435                        for (it = beam.mViewCells.begin(); it != beam.mViewCells.end(); ++ it)
436                        {
437                                BspNodeGeometry geom;
438                                AxisAlignedBox3 vbox;
439                                vbox.Initialize();
440                                vbox.Include((*it)->GetMesh());
441                       
442                                exporter->SetWireframe();
443                                exporter->ExportBox(vbox);
444                                exporter->SetFilled();
445                                exporter->ExportViewCell(*it);
446                        }
447
448                        /*vector<KdNode *>::const_iterator it, it_end = beam.mKdNodes.end();
449                       
450                        for (it = beam.mKdNodes.begin(); it != beam.mKdNodes.end(); ++ it)
451                        {
452                                exporter->ExportBox(mKdTree->GetBox((*it)));
453                        }*/
454                }
455        }
456        /*while (1)
457        { debuggerWidget->repaint();
458        };*/
459        delete exporter;
460}
461
462
463float
464VssPreprocessor::GetAvgPvsSize(VssTree *tree,
465                                                           const vector<AxisAlignedBox3> &viewcells
466                                                           )
467{
468  vector<AxisAlignedBox3>::const_iterator it, it_end = viewcells.end();
469
470  int sum = 0;
471  for (it = viewcells.begin(); it != it_end; ++ it)
472        sum += tree->GetPvsSize(*it);
473
474  return sum/(float)viewcells.size();
475}
476
477bool
478VssPreprocessor::ComputeVisibility()
479{
480
481
482  long startTime = GetTime();
483
484  int totalSamples = 0;
485
486
487  AxisAlignedBox3 *box = new AxisAlignedBox3(mKdTree->GetBox());
488 
489  if (!useViewspacePlane) {
490        float size = 0.05f;
491        float s = 0.5f - size;
492        float olds = Magnitude(box->Size());
493        box->Enlarge(box->Size()*Vector3(-s));
494        Vector3 translation = Vector3(-olds*0.1f, 0, 0);
495        box->SetMin(box->Min() + translation);
496        box->SetMax(box->Max() + translation);
497  } else {
498
499        // sample city like heights
500        box->SetMin(1, box->Min(1) + box->Size(1)*0.2f);
501        box->SetMax(1, box->Min(1) + box->Size(1)*0.3f);
502  }
503
504  if (use2dSampling)
505        box->SetMax(1, box->Min(1));
506
507  cout<<"mUseViewSpaceBox="<<mUseViewSpaceBox<<endl;
508  if (mUseViewSpaceBox)
509  {
510        mViewSpaceBox = box;
511        mViewCellsManager->SetViewSpaceBox(*box);
512  }
513  else
514  {
515        mViewSpaceBox = NULL;
516        mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());
517  }
518 
519  //-- load view cells from file if requested
520  if (mLoadViewCells)
521  {     
522          // load now because otherwise bounding box not correct
523          mViewCellsManager->LoadViewCells(mViewCellsFilename, &mObjects);
524  }
525
526
527  VssTree *vssTree = NULL;
528
529  mSceneGraph->CollectObjects(&mObjects);
530
531  long initialTime = GetTime();
532
533  if (mLoadInitialSamples)
534  {
535          cout << "Loading samples from file ... ";
536          LoadSamples(mVssRays, mObjects);
537          cout << "finished\n" << endl;
538          totalSamples = (int)mVssRays.size();
539  }
540  else
541  {
542       
543        while (totalSamples < mInitialSamples) {
544                int passContributingSamples = 0;
545                int passSampleContributions = 0;
546                int passSamples = 0;
547
548                int index = 0;
549
550                int sampleContributions;
551
552                int s = Min(mSamplesPerPass, mInitialSamples);
553                for (int k=0; k < s; k++) {
554                        // changed by matt
555                        Vector3 viewpoint;
556                        //                      viewpoint = GetViewpoint(mViewSpaceBox);
557                        mViewCellsManager->GetViewPoint(viewpoint);
558                        Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
559
560                        sampleContributions = CastRay(viewpoint, direction, mVssRays);
561
562                        if (sampleContributions) {
563                                passContributingSamples ++;
564                                passSampleContributions += sampleContributions;
565                        }
566                        passSamples++;
567                        totalSamples++;
568                }
569
570                mPass++;
571                int pvsSize = 0;
572                float avgRayContrib = (passContributingSamples > 0) ?
573                        passSampleContributions/(float)passContributingSamples : 0;
574
575                cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
576                cout << "#TotalSamples=" << totalSamples/1000
577                        << "k   #SampleContributions=" << passSampleContributions << " ("
578                        << 100*passContributingSamples/(float)passSamples<<"%)" << " avgPVS="
579                        << pvsSize/(float)mObjects.size() << endl
580                        << "avg ray contrib=" << avgRayContrib << endl;
581
582                mStats <<
583                        "#Pass\n" <<mPass<<endl<<
584                        "#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl<<
585                        "#TotalSamples\n" << totalSamples<< endl<<
586                        "#SampleContributions\n" << passSampleContributions << endl <<
587                        "#PContributingSamples\n"<<100*passContributingSamples/(float)passSamples<<endl <<
588                        "#AvgPVS\n"<< pvsSize/(float)mObjects.size() << endl <<
589                        "#AvgRayContrib\n" << avgRayContrib << endl;
590          }
591 
592          cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
593
594
595         
596  }
597 
598  cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl << flush;
599  Debug << (int)mVssRays.size() << " rays generated in "
600            << TimeDiff(initialTime, GetTime()) * 1e-3 << " seconds" << endl;
601
602  if (mStoreInitialSamples)
603  {
604          cout << "Writing " << (int)mVssRays.size() << " samples to file ... ";
605          ExportSamples(mVssRays);
606          cout << "finished\n" << endl;
607
608          /*VssRayContainer dummyRays;
609          LoadSamples(dummyRays, mObjects);
610          Debug << "rays " << (int)mVssRays.size() << " " << dummyRays.size() << endl;
611
612          for (int i = 0; i < (int)mVssRays.size(); ++ i)
613          {
614                  Debug << mVssRays[i]->GetOrigin() << " " << mVssRays[i]->GetTermination() << " " << mVssRays[i]->mOriginObject << " " << mVssRays[i]->mTerminationObject << endl;
615                  Debug << dummyRays[i]->GetOrigin() << " " << dummyRays[i]->GetTermination() << " " << dummyRays[i]->mOriginObject << " " << dummyRays[i]->mTerminationObject << endl << endl;
616          }*/
617  }
618
619 
620  //int numExportRays = 5000;
621  int numExportRays = 0;
622
623  if (numExportRays) {
624        char filename[64];
625        sprintf(filename, "vss-rays-initial.x3d");
626        ExportRays(filename, mVssRays, numExportRays);
627  }
628
629  /// compute view cell contribution of rays if view cells manager already constructed
630  mViewCellsManager->ComputeSampleContributions(mVssRays);
631
632  // construct view cells
633  if (!mDelayedViewCellsConstruction)
634        mViewCellsManager->Construct(mObjects, mVssRays);
635 
636  vssTree = new VssTree;
637  // viewcells = Construct(mVssRays);
638
639  vssTree->Construct(mVssRays, mViewSpaceBox);
640  cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
641
642  if (0)
643  {
644          ExportVssTree("vss-tree-100.x3d", vssTree, Vector3(1,0,0));
645          ExportVssTree("vss-tree-001.x3d", vssTree, Vector3(0,0,1));
646          ExportVssTree("vss-tree-101.x3d", vssTree, Vector3(1,0,1));
647          ExportVssTree("vss-tree-101m.x3d", vssTree, Vector3(-1,0,-1));
648          ExportVssTreeLeaves(vssTree, 10);
649  }
650
651  // viewcells->UpdatePVS(newVssRays);
652  // get viewcells as kd tree boxes
653  vector<AxisAlignedBox3> kdViewcells;
654  if (0) {
655        vector<KdLeaf *> leaves;
656        mKdTree->CollectLeaves(leaves);
657        vector<KdLeaf *>::const_iterator it;
658        int targetLeaves = 50;
659        float prob = targetLeaves/(float)leaves.size();
660        for (it = leaves.begin(); it != leaves.end(); ++it)
661          if (RandomValue(0.0f,1.0f) < prob)
662                kdViewcells.push_back(mKdTree->GetBox(*it));
663
664        float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
665        cout<<"Initial average PVS size = "<<avgPvs<<endl;
666  }
667
668
669  int samples = 0;
670  int pass = 0;
671
672 
673  // cast view cell samples
674  while (1) {
675        int num = mVssSamplesPerPass;
676        SimpleRayContainer rays;
677        VssRayContainer vssRays;
678
679        if (!mUseImportanceSampling) {
680          for (int j=0; j < num; j++) {
681            // changed by matt
682                //Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
683                Vector3 viewpoint;
684                mViewCellsManager->GetViewPoint(viewpoint);
685                Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
686                rays.push_back(SimpleRay(viewpoint, direction));
687          }
688        } else {
689          num = GenerateImportanceRays(vssTree, num, rays);
690        }
691
692        for (int i=0; i < rays.size(); i++)
693          CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);
694
695        vssTree->AddRays(vssRays);
696
697        if (0) {
698          int subdivided = vssTree->UpdateSubdivision();
699          cout<<"subdivided leafs = "<<subdivided<<endl;
700        }
701
702        float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
703        cout<<"Average PVS size = "<<avgPvs<<endl;
704
705        //Debug << "samples: " << samples << " construction samples " << mViewCellsManager->GetConstructionSamples() << endl;
706        // construct view cells after vss
707        if (!mViewCellsManager->ViewCellsConstructed() &&
708                (samples + mInitialSamples >  mViewCellsManager->GetConstructionSamples()))
709        {
710                VssRayContainer constructionRays;
711                vssTree->CollectRays(constructionRays,
712                                                         mViewCellsManager->GetConstructionSamples());
713                mViewCellsManager->Construct(mObjects, constructionRays);
714        }
715
716        /// compute view cell contribution of rays
717        mViewCellsManager->ComputeSampleContributions(vssRays);
718       
719        if (numExportRays) {
720          char filename[64];
721          if (mUseImportanceSampling)
722                sprintf(filename, "vss-rays-i%04d.x3d", pass);
723          else
724                sprintf(filename, "vss-rays-%04d.x3d", pass);
725
726          ExportRays(filename, vssRays, numExportRays);
727        }
728
729        samples+=num;
730        float pvs = vssTree->GetAvgPvsSize();
731        cout<<"*****************************\n";
732        cout<<samples<<" avgPVS ="<<pvs<<endl;
733        cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
734        cout<<"*****************************\n";
735        if (samples >= mVssSamples)
736          break;
737        pass++;
738  }
739
740  Debug << vssTree->stat << endl;
741  VssRayContainer viewCellRays;
742 
743  // compute rays used for view cells construction
744  int numRays = Max(mViewCellsManager->GetPostProcessSamples(),
745                                        mViewCellsManager->GetVisualizationSamples());
746
747  vssTree->CollectRays(viewCellRays, numRays);
748 
749  //-- post process view cells
750  mViewCellsManager->PostProcess(mObjects, viewCellRays);
751
752  if (mTestBeamSampling && mUseGlRenderer)
753  {     
754          TestBeamCasting(vssTree, mViewCellsManager, mObjects);
755  }
756
757  //-- several visualizations and statistics
758  Debug << "\nview cells after post processing: " << endl;
759  mViewCellsManager->PrintStatistics(Debug);
760
761  mViewCellsManager->Visualize(mObjects, viewCellRays);
762 
763  //-- render simulation after merge
764  cout << "\nevaluating bsp view cells render time after merge ... ";
765  mRenderSimulator->RenderScene();
766  SimulationStatistics ss;
767  mRenderSimulator->GetStatistics(ss);
768 
769  cout << " finished" << endl;
770  cout << ss << endl;
771  Debug << ss << endl;
772
773  delete vssTree;
774 
775  return true;
776}
Note: See TracBrowser for help on using the repository browser.