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

Revision 2542, 16.1 KB checked in by mattausch, 17 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#include "Intersectable.h"
16#include "RayCaster.h"
17#include "SamplingStrategy.h"
18#include "ViewCellBsp.h"
19
20
21namespace GtpVisibilityPreprocessor {
22
23
24bool use2dSampling = false;
25bool useViewspacePlane = false;
26
27VssPreprocessor::VssPreprocessor():
28  mVssRays()
29{
30  // this should increase coherence of the samples
31  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.samplesPerPass", mSamplesPerPass);
32  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.initialSamples", mInitialSamples);
33  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.vssSamples", mVssSamples);
34  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.vssSamplesPerPass", mVssSamplesPerPass);
35  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.useImportanceSampling", mUseImportanceSampling);
36 
37  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.loadInitialSamples", mLoadInitialSamples);
38  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.storeInitialSamples", mStoreInitialSamples);
39  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.testBeamSampling", mTestBeamSampling);
40  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.enlargeViewSpace", mEnlargeViewSpace);
41  Environment::GetSingleton()->GetBoolValue("Preprocessor.detectEmptyViewSpace", mDetectEmptyViewSpace);
42 
43  useViewspacePlane = mUseViewSpaceBox; //hack
44 
45  Debug << "*********** vss preprocessor options **************" << endl;
46  Debug << "use view space box=" << mUseViewSpaceBox << endl;
47  Debug << "enlarge view space=" << mEnlargeViewSpace << endl;
48  Debug << "*********** end vss preprocessor options **************" << endl;
49
50}
51
52
53VssPreprocessor::~VssPreprocessor()
54{
55        CLEAR_CONTAINER(mVssRays);
56}
57
58
59Vector3
60VssPreprocessor::GetViewpoint(AxisAlignedBox3 *viewSpaceBox)
61{
62  AxisAlignedBox3 box;
63
64  if (viewSpaceBox)
65        box =*viewSpaceBox;
66  else
67        box = mKdTree->GetBox();
68
69  // shrink the box in the y direction
70  return box.GetRandomPoint();
71}
72
73Vector3
74VssPreprocessor::GetDirection(const Vector3 &viewpoint,
75                                                          AxisAlignedBox3 *viewSpaceBox
76                                                          )
77{
78  Vector3 point;
79  if (!use2dSampling)
80  {
81          if (0)
82          {
83                  Vector3 normal;
84                  int i = Random((int)mObjects.size());
85                  Intersectable *object = mObjects[i];
86                  object->GetRandomSurfacePoint(point, normal);
87          }
88          else
89                  point = mKdTree->GetBox().GetRandomPoint();
90        //        point = viewpoint + UniformRandomVector();
91  }
92  else
93  {
94          AxisAlignedBox3 box;
95
96          if (viewSpaceBox)
97                  box =*viewSpaceBox;
98          else
99                  box = mKdTree->GetBox();
100
101          point = box.GetRandomPoint();
102          point.y = viewpoint.y;
103  }
104
105  return point - viewpoint;
106}
107
108int
109VssPreprocessor::GenerateImportanceRays(VssTree *vssTree,
110                                                                                const int desiredSamples,
111                                                                                SimpleRayContainer &rays
112                                                                                )
113{
114  int num;
115  if (0) {
116        float minRayContribution;
117        float maxRayContribution;
118        float avgRayContribution;
119
120        vssTree->GetRayContributionStatistics(minRayContribution,
121                                                                                  maxRayContribution,
122                                                                                  avgRayContribution);
123
124        cout<<
125          "#MIN_RAY_CONTRIB\n"<<minRayContribution<<endl<<
126          "#MAX_RAY_CONTRIB\n"<<maxRayContribution<<endl<<
127          "#AVG_RAY_CONTRIB\n"<<avgRayContribution<<endl;
128
129        float p = desiredSamples/(float)(avgRayContribution*vssTree->stat.Leaves());
130        num = vssTree->GenerateRays(p, rays);
131  } else {
132        int leaves = vssTree->stat.Leaves();
133        num = vssTree->GenerateRays(desiredSamples, leaves, rays);
134  }
135
136  cout<<"Generated "<<num<<" rays."<<endl;
137
138  return num;
139}
140
141
142bool
143VssPreprocessor::ExportRays(const char *filename,
144                                                        const VssRayContainer &vssRays,
145                                                        const int number,
146                                                        const bool exportScene
147                                                        )
148{
149  cout<<"Exporting vss rays..."<<endl<<flush;
150
151  Exporter *exporter = NULL;
152  exporter = Exporter::GetExporter(filename);
153  exporter->SetWireframe();
154  exporter->ExportKdTree(*mKdTree);
155  exporter->SetFilled();
156  exporter->ExportScene(mSceneGraph->GetRoot());
157  exporter->SetWireframe();
158
159  exporter->SetForcedMaterial(RgbColor(1,0,1));
160  exporter->ExportBox(mViewCellsManager->GetViewSpaceBox());
161  exporter->ResetForcedMaterial();
162
163
164  VssRayContainer rays;
165  vssRays.SelectRays(number, rays);
166 
167  //exporter->ExportRays(rays, RgbColor(1, 0, 0));
168
169  delete exporter;
170
171  cout<<"done."<<endl<<flush;
172
173  return true;
174}
175
176
177bool
178VssPreprocessor::ExportVssTree(char *filename,
179                                                           VssTree *tree,
180                                                           const Vector3 &dir
181                                                           )
182{
183  Exporter *exporter = Exporter::GetExporter(filename);
184  exporter->SetFilled();
185  exporter->ExportScene(mSceneGraph->GetRoot());
186  //  exporter->SetWireframe();
187  bool result = exporter->ExportVssTree2( *tree, dir );
188  delete exporter;
189  return result;
190}
191
192bool
193VssPreprocessor::ExportVssTreeLeaf(char *filename,
194                                                                   VssTree *tree,
195                                                                   VssTreeLeaf *leaf)
196{
197  Exporter *exporter = NULL;
198  exporter = Exporter::GetExporter(filename);
199  exporter->SetWireframe();
200  exporter->ExportKdTree(*mKdTree);
201
202  exporter->SetForcedMaterial(RgbColor(1,0,0));
203  exporter->ExportBox(mViewCellsManager->GetViewSpaceBox());
204  exporter->ResetForcedMaterial();
205
206  exporter->SetForcedMaterial(RgbColor(0,0,1));
207  exporter->ExportBox(tree->GetBBox(leaf));
208  exporter->ResetForcedMaterial();
209
210  VssRayContainer rays[4];
211  for (int i=0; i < leaf->rays.size(); i++) {
212        int k = leaf->rays[i].GetRayClass();
213        rays[k].push_back(leaf->rays[i].mRay);
214  }
215
216  // SOURCE RAY
217  exporter->ExportRays(rays[0], RgbColor(1, 0, 0));
218  // TERMINATION RAY
219  exporter->ExportRays(rays[1], RgbColor(1, 1, 1));
220  // PASSING_RAY
221  exporter->ExportRays(rays[2], RgbColor(1, 1, 0));
222  // CONTAINED_RAY
223  exporter->ExportRays(rays[3], RgbColor(0, 0, 1));
224
225  delete exporter;
226  return true;
227}
228
229void
230VssPreprocessor::ExportVssTreeLeaves(VssTree *tree, const int number)
231{
232  vector<VssTreeLeaf *> leaves;
233  tree->CollectLeaves(leaves);
234
235  int num = 0;
236  int i;
237  float p = number / (float)leaves.size();
238  for (i=0; i < leaves.size(); i++) {
239        if (RandomValue(0,1) < p) {
240          char filename[64];
241          sprintf(filename, "vss-leaf-%04d.x3d", num);
242          ExportVssTreeLeaf(filename, tree, leaves[i]);
243          num++;
244        }
245        if (num >= number)
246          break;
247  }
248}
249
250
251void VssPreprocessor::TestBeamCasting(VssTree *tree,
252                                                                          ViewCellsManager *vm,
253                                                                          const ObjectContainer &objects)
254{
255        //debuggerWidget = new GlDebuggerWidget(renderer);
256        //renderer->resize(640, 480);
257        //debuggerWidget->resize(640, 480);
258
259        vector<VssTreeLeaf *> leaves;
260        tree->CollectLeaves(leaves);
261
262        Exporter *exporter = Exporter::GetExporter("shafts.x3d");
263
264        exporter->SetWireframe();
265        exporter->ExportGeometry(objects);
266        exporter->SetFilled();
267       
268        //Randomize();
269        //§§matt
270        //debuggerWidget = new GlDebuggerWidget(renderer);
271
272        /*
273        debuggerWidget->mBeam = beam;
274        debuggerWidget->mSourceObject = sourceObj;
275        debuggerWidget->mSamples = 10000;
276       
277        Debug << "showing window" << endl;
278        debuggerWidget->show();
279       
280        renderer->makeCurrent();
281        */
282
283        for (int i = 0; i < 10; ++ i)
284        {
285                Beam beam;
286                Intersectable *sourceObj = mObjects[5];
287
288                const int index = (int)RandomValue(0, (Real)((float)leaves.size() - 0.5f));
289                VssTreeLeaf *leaf = leaves[index];
290
291                AxisAlignedBox3 dirBox = tree->GetDirBBox(leaf);
292                AxisAlignedBox3 box = tree->GetBBox(leaf);
293               
294                beam.Construct(box, dirBox);
295
296                // collect kd leaves and view cells
297                mKdTree->CastBeam(beam);
298                vm->CastBeam(beam);
299
300                Debug << "found " << (int)beam.mViewCells.size() << " view cells and "
301                          << (int)beam.mKdNodes.size() << " kd nodes" << endl;
302
303                BeamSampleStatistics stats;
304
305                // §§matt
306                /*     
307                renderer->SampleBeamContributions(sourceObj,
308                                                                                  beam,
309                                                                                  200000,
310                                                                                  stats);
311
312                char s[64]; sprintf(s, "shaft%04d.png", i);
313
314                QImage image = renderer->toImage();
315                image.save(s, "PNG");
316                Debug << "beam statistics: " << stats << endl << endl;
317                */
318
319                if (1)
320                {
321                        AxisAlignedBox3 sbox = mSceneGraph->GetBox();
322                        Vector3 bmin = sbox.Min() - 150.0f;
323                        Vector3 bmax = sbox.Max() + 150.0f;
324                        AxisAlignedBox3 vbox(bmin, bmax);
325               
326                        exporter->ExportBeam(beam, vbox);
327                }
328
329                const bool exportViewCells = false;
330
331                if (exportViewCells)
332                {
333                        ViewCellContainer::const_iterator it, it_end = beam.mViewCells.end();
334                       
335                        for (it = beam.mViewCells.begin(); it != beam.mViewCells.end(); ++ it)
336                        {
337                                BspNodeGeometry geom;
338                                AxisAlignedBox3 vbox;
339                                vbox.Initialize();
340                                vbox.Include((*it)->GetMesh());
341                       
342                                exporter->SetWireframe();
343                                exporter->ExportBox(vbox);
344                                exporter->SetFilled();
345                                exporter->ExportViewCell(*it);
346                        }
347                }
348        }
349       
350        delete exporter;
351}
352
353
354float
355VssPreprocessor::GetAvgPvsSize(VssTree *tree,
356                                                           const vector<AxisAlignedBox3> &viewcells
357                                                           )
358{
359  vector<AxisAlignedBox3>::const_iterator it, it_end = viewcells.end();
360
361  int sum = 0;
362  for (it = viewcells.begin(); it != it_end; ++ it)
363        sum += tree->GetPvsSize(*it);
364
365  return sum/(float)viewcells.size();
366}
367
368bool
369VssPreprocessor::ComputeVisibility()
370{
371        Debug << "type: vss" << endl;
372
373        const long startTime = GetTime();
374        int totalSamples = 0;
375
376        if (!mLoadViewCells)
377        {
378                // generate new view cells from the scratch using coarse sampling
379                ConstructViewCells();
380        }
381#if 0
382        else
383        {       
384                // load view cells from file
385                // we test success by exporting view cells again
386                VssRayContainer dummyContainer;
387                mViewCellsManager->Visualize(mObjects, dummyContainer);
388               
389                mViewCellsManager->ExportViewCells("test.xml.zip", mViewCellsManager->GetExportPvs(), mObjects);
390        }
391#endif
392
393        VssTree *vssTree = NULL;
394        const long initialTime = GetTime();
395
396        if (mLoadInitialSamples)
397        {
398                cout << "Loading samples from file ... ";
399               
400                LoadSamples(mVssRays, mObjects);
401               
402                cout << "finished\n" << endl;
403                totalSamples = (int)mVssRays.size();
404        }
405        else
406        {
407                while (totalSamples < mInitialSamples)
408                {
409                        int passContributingSamples = 0;
410                        int passSampleContributions = 0;
411                        int passSamples = 0;
412
413                        int index = 0;
414
415                        int sampleContributions;
416
417                        int s = Min(mSamplesPerPass, mInitialSamples);
418                        for (int k=0; k < s; k++)
419                        {
420                                Vector3 viewpoint;
421
422                                mViewCellsManager->GetViewPoint(viewpoint);
423                                AxisAlignedBox3 vspBox = mViewCellsManager->GetViewSpaceBox();
424                                const Vector3 direction = GetDirection(viewpoint, &vspBox);
425
426                                const SimpleRay sray(viewpoint, direction,
427                                                                         SamplingStrategy::DIRECTION_BOX_BASED_DISTRIBUTION,
428                                                                         1.0f);
429                                sampleContributions = mRayCaster->CastRay(sray,
430                                                                                                                  mVssRays,
431                                                                                                                  mViewCellsManager->GetViewSpaceBox(),
432                                                                                                                  true);
433
434                                if (sampleContributions) {
435                                        passContributingSamples ++;
436                                        passSampleContributions += sampleContributions;
437                                }
438                                passSamples++;
439                                totalSamples++;
440                        }
441
442                        mPass++;
443                        int pvsSize = 0;
444                        float avgRayContrib = (passContributingSamples > 0) ?
445                                passSampleContributions/(float)passContributingSamples : 0;
446
447                        cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
448                        cout << "#TotalSamples=" << totalSamples/1000
449                                << "#SampleContributions=" << passSampleContributions << " ("
450                                << 100*passContributingSamples/(float)passSamples<<"%)" << " avgPVS="
451                                << pvsSize/(float)mObjects.size() << endl
452                                << "avg ray contrib=" << avgRayContrib << endl;
453
454                        mStats <<
455                                "#Pass\n" <<mPass<<endl<<
456                                "#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl<<
457                                "#TotalSamples\n" << totalSamples<< endl<<
458                                "#SampleContributions\n" << passSampleContributions << endl <<
459                                "#PContributingSamples\n"<<100*passContributingSamples/(float)passSamples<<endl <<
460                                "#AvgPVS\n"<< pvsSize/(float)mObjects.size() << endl <<
461                                "#AvgRayContrib\n" << avgRayContrib << endl;
462                }
463        }
464
465
466        cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl << flush;
467        Debug << (int)mVssRays.size() << " rays generated in "
468                << TimeDiff(initialTime, GetTime()) * 1e-3 << " seconds" << endl;
469
470        if (mStoreInitialSamples)
471        {
472                cout << "Writing " << (int)mVssRays.size() << " samples to file ... ";
473                ExportSamples(mVssRays);
474                cout << "finished\n" << endl;
475        }
476
477
478        //int numExportRays = 2000;
479        int numExportRays = 0;
480
481        if (numExportRays) {
482                char filename[64];
483                sprintf(filename, "vss-rays-initial.x3d");
484                ExportRays(filename, mVssRays, numExportRays);
485        }
486
487        vssTree = new VssTree;
488        // viewcells = Construct(mVssRays);
489
490        vssTree->Construct(mVssRays, NULL);
491        cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
492
493        if (0) ExportRays("kdtree.x3d", mVssRays, 10);
494
495        if (0)
496        {
497                ExportVssTree("vss-tree-100.x3d", vssTree, Vector3(1,0,0));
498                ExportVssTree("vss-tree-001.x3d", vssTree, Vector3(0,0,1));
499                ExportVssTree("vss-tree-101.x3d", vssTree, Vector3(1,0,1));
500                ExportVssTree("vss-tree-101m.x3d", vssTree, Vector3(-1,0,-1));
501                ExportVssTreeLeaves(vssTree, 10);
502        }
503
504        // viewcells->UpdatePVS(newVssRays);
505        // get viewcells as kd tree boxes
506        vector<AxisAlignedBox3> kdViewcells;
507        if (0)
508        {
509                vector<KdLeaf *> leaves;
510                mKdTree->CollectLeaves(leaves);
511                vector<KdLeaf *>::const_iterator it;
512                int targetLeaves = 50;
513                float prob = targetLeaves/(float)leaves.size();
514                for (it = leaves.begin(); it != leaves.end(); ++it)
515                        if (RandomValue(0.0f,1.0f) < prob)
516                                kdViewcells.push_back(mKdTree->GetBox(*it));
517
518                float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
519                cout<<"Initial average PVS size = "<<avgPvs<<endl;
520        }
521
522
523        int samples = 0;
524        int pass = 0;
525
526
527        // cast view cell samples
528        while (samples < mVssSamples)
529        {
530                int num = mVssSamplesPerPass;
531                SimpleRayContainer rays;
532                VssRayContainer vssRays;
533
534                if (!mUseImportanceSampling)
535                {
536                        for (int j=0; j < num; j++) {
537                                Vector3 viewpoint;
538                                mViewCellsManager->GetViewPoint(viewpoint);
539                                Vector3 direction = GetDirection(viewpoint, NULL);
540                                rays.push_back(SimpleRay(viewpoint, direction,
541                                                                                 SamplingStrategy::DIRECTION_BOX_BASED_DISTRIBUTION,
542                                                                                 1.0f)
543                                                           );
544                        }
545                }
546                else
547                {
548                        num = GenerateImportanceRays(vssTree, num, rays);
549                }
550
551                CastRays(rays, vssRays, true);
552                vssTree->AddRays(vssRays);
553
554                if (0)
555                {
556                        int subdivided = vssTree->UpdateSubdivision();
557                        cout<<"subdivided leafs = "<<subdivided<<endl;
558                }
559
560                float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
561                cout<<"Average PVS size = "<<avgPvs<<endl;
562
563                /// compute view cell contribution of rays
564                mViewCellsManager->ComputeSampleContributions(vssRays, true, false);
565
566                if (numExportRays) {
567                        char filename[64];
568                        if (mUseImportanceSampling)
569                                sprintf(filename, "vss-rays-i%04d.x3d", pass);
570                        else
571                                sprintf(filename, "vss-rays-%04d.x3d", pass);
572
573                        ExportRays(filename, vssRays, numExportRays);
574                }
575
576                samples += num;
577
578                float pvs = vssTree->GetAvgPvsSize();
579                cout<<"*****************************\n";
580                cout<<samples<<" avgPVS ="<<pvs<<endl;
581                cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
582                cout<<"*****************************\n";
583                //      if (samples >= mVssSamples) break;
584                pass ++;
585        }
586
587        if (mTestBeamSampling && mUseGlRenderer)
588        {       
589                TestBeamCasting(vssTree, mViewCellsManager, mObjects);
590        }
591
592        if (0)  Debug << vssTree->stat << endl;
593
594        if (0)
595        {
596                VssRayContainer viewCellRays;
597                // compute rays used for view cells construction
598                const int numRays = mViewCellsManager->GetVisualizationSamples();
599                vssTree->CollectRays(viewCellRays, numRays);
600        }
601
602
603        ////////////////////
604        //-- render simulation after construction
605
606        mRenderSimulator->RenderScene();
607        SimulationStatistics ss;
608        mRenderSimulator->GetStatistics(ss);
609        Debug << "\nFinal view cells partition render time\n" << ss << endl;
610        cout << "\nFinal view cells partition render time\n" << ss << endl;
611
612        delete vssTree;
613
614        return true;
615}
616
617
618void VssPreprocessor::DeterminePvsObjects(VssRayContainer &rays)
619{
620        // store higher order object
621        mViewCellsManager->DeterminePvsObjects(rays, !mViewCellsManager->ViewCellsConstructed());
622}
623
624
625}
Note: See TracBrowser for help on using the repository browser.