source: GTP/trunk/Lib/Vis/Preprocessing/src/VssPreprocessor.cpp @ 675

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