source: GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.cpp @ 1524

Revision 1524, 23.3 KB checked in by mattausch, 18 years ago (diff)
Line 
1#include "SceneGraph.h"
2#include "Exporter.h"
3#include "UnigraphicsParser.h"
4#include "X3dParser.h"
5#include "Preprocessor.h"
6#include "ViewCell.h"
7#include "Environment.h"
8#include "ViewCellsManager.h"
9#include "ViewCellBsp.h"
10#include "VspBspTree.h"
11#include "RenderSimulator.h"
12#include "GlRenderer.h"
13#include "PlyParser.h"
14#include "SamplingStrategy.h"
15#include "VspTree.h"
16#include "OspTree.h"
17#include "ObjParser.h"
18#include "BvHierarchy.h"
19#include "HierarchyManager.h"
20#include "VssRay.h"
21#include "IntelRayCaster.h"
22#include "InternalRayCaster.h"
23
24
25
26#define DEBUG_RAYCAST 0
27
28
29namespace GtpVisibilityPreprocessor {
30
31const static bool ADDITIONAL_GEOMETRY_HACK = false;
32
33
34// HACK: Artificially modify scene to watch rendercost changes
35static void AddGeometry(SceneGraph *scene)
36{
37        scene->GetRoot()->UpdateBox();
38
39        AxisAlignedBox3 sceneBox = scene->GetBox();
40
41        int n = 200;
42
43        if (0)
44        {
45                // form grid of boxes
46                for (int i = 0; i < n; ++ i)
47                {
48                        for (int j = 0; j < n; ++ j)
49                        {
50                                const Vector3 scale2((float)j * 0.8f / n + 0.1f,  0.05f, (float)i * 0.8f  / (float)n + 0.1f);
51
52                                const Vector3 pt2 = sceneBox.Min() + scale2 * (sceneBox.Max() - sceneBox.Min());
53
54                                const Vector3 boxSize = sceneBox.Size() * Vector3(0.0025f, 0.01f, 0.0025f);
55                                AxisAlignedBox3 box(pt2, pt2 + boxSize);
56                                Mesh *mesh = CreateMeshFromBox(box);
57
58                                mesh->Preprocess();
59
60                                MeshInstance *mi = new MeshInstance(mesh);
61                                scene->GetRoot()->mGeometry.push_back(mi);
62                        }
63                }
64
65                for (int i = 0; i < n; ++ i)
66                {
67                        for (int j = 0; j < n; ++ j)
68                        {
69                                const Vector3 scale2(0.15f, (float)j * 0.8f / n + 0.1f, (float)i * 0.8f  / (float)n + 0.1f);
70
71                                Vector3 pt2 = sceneBox.Min() + scale2 * (sceneBox.Max() - sceneBox.Min());
72
73                                Vector3 boxSize = sceneBox.Size() * Vector3(0.0025f, 0.01f, 0.0025f);
74                                AxisAlignedBox3 box(pt2, pt2 + boxSize);
75                                Mesh *mesh = CreateMeshFromBox(box);
76
77                                mesh->Preprocess();
78
79                                MeshInstance *mi = new MeshInstance(mesh);
80                                scene->GetRoot()->mGeometry.push_back(mi);
81                        }
82                }
83
84                for (int i = 0; i < n; ++ i)
85                {
86                        const Vector3 scale2(2, 0.2f, (float)i * 0.8f  / (float)n + 0.1f);
87
88                        Vector3 pt2 = sceneBox.Min() + scale2 * (sceneBox.Max() - sceneBox.Min());
89
90                        //Vector3 boxSize = sceneBox.Size() * Vector3(0.0025, 0.01, 0.0025);
91                        Vector3 boxSize = sceneBox.Size() * Vector3(0.005f, 0.02f, 0.005f);
92
93                        AxisAlignedBox3 box(pt2 + 0.1f, pt2 + boxSize);
94                        Mesh *mesh = CreateMeshFromBox(box);
95
96                        mesh->Preprocess();
97
98                        MeshInstance *mi = new MeshInstance(mesh);
99                        scene->GetRoot()->mGeometry.push_back(mi);
100                }
101
102                scene->GetRoot()->UpdateBox();
103        }
104
105        if (1)
106        {
107                // plane separating view space regions
108                const Vector3 scale(1.0f, 0.0, 0);
109
110                Vector3 pt = sceneBox.Min() + scale * (sceneBox.Max() - sceneBox.Min());
111
112                Plane3 cuttingPlane(Vector3(1, 0, 0), pt);
113                Mesh *planeMesh = new Mesh();
114
115                Polygon3 *poly = sceneBox.CrossSection(cuttingPlane);
116                IncludePolyInMesh(*poly, *planeMesh);
117
118                planeMesh->Preprocess();
119
120                MeshInstance *planeMi = new MeshInstance(planeMesh);
121                scene->GetRoot()->mGeometry.push_back(planeMi);
122        }       
123}
124
125
126Preprocessor::Preprocessor():
127mKdTree(NULL),
128mBspTree(NULL),
129mVspBspTree(NULL),
130mHierarchyManager(NULL),
131mViewCellsManager(NULL),
132mRenderSimulator(NULL),
133mPass(0),
134mSceneGraph(NULL),
135mRayCaster(NULL)
136{
137        Environment::GetSingleton()->GetBoolValue("Preprocessor.useGlRenderer", mUseGlRenderer);
138 
139        // renderer will be constructed when the scene graph and viewcell manager will be known
140        renderer = NULL;
141 
142        Environment::GetSingleton()->GetBoolValue("Preprocessor.useGlDebugger", mUseGlDebugger);
143        Environment::GetSingleton()->GetBoolValue("Preprocessor.loadMeshes", mLoadMeshes);
144        Environment::GetSingleton()->GetBoolValue("Preprocessor.quitOnFinish", mQuitOnFinish);
145        Environment::GetSingleton()->GetBoolValue("Preprocessor.computeVisibility", mComputeVisibility);
146        Environment::GetSingleton()->GetBoolValue("Preprocessor.detectEmptyViewSpace", mDetectEmptyViewSpace);
147        Environment::GetSingleton()->GetBoolValue("Preprocessor.exportVisibility", mExportVisibility );
148       
149        char buffer[256];
150        Environment::GetSingleton()->GetStringValue("Preprocessor.visibilityFile",  buffer);
151   
152        mVisibilityFileName = buffer;
153        Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilityFilter", mApplyVisibilityFilter );
154        Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilitySpatialFilter",
155                                                          mApplyVisibilitySpatialFilter );
156        Environment::GetSingleton()->GetFloatValue("Preprocessor.visibilityFilterWidth", mVisibilityFilterWidth);
157
158        Debug << "detect empty view space=" << mDetectEmptyViewSpace << endl;
159        Debug << "load meshes: " << mLoadMeshes << endl;
160}
161
162
163Preprocessor::~Preprocessor()
164{
165        cout << "cleaning up" << endl;
166
167        cout << "Deleting view cells manager ... \n";
168        DEL_PTR(mViewCellsManager);
169        cout << "done.\n";
170
171        cout << "Deleting bsp tree ... \n";
172        DEL_PTR(mBspTree);
173        cout << "done.\n";
174
175        cout << "Deleting kd tree...\n";
176        DEL_PTR(mKdTree);
177        cout << "done.\n";
178
179        cout << "Deleting hierarchy manager...\n";
180        DEL_PTR(mHierarchyManager);
181        cout << "done.\n";
182
183        cout << "Deleting vspbsp tree...\n";
184        DEL_PTR(mVspBspTree);
185        cout << "done.\n";
186
187        cout << "Deleting scene graph...\n";
188        DEL_PTR(mSceneGraph);
189        cout << "done.\n";
190
191        DEL_PTR(mRenderSimulator);
192        DEL_PTR(renderer);
193        DEL_PTR(mRayCaster);
194}
195
196
197GlRendererBuffer *Preprocessor::GetRenderer()
198{
199        return renderer;
200}
201
202
203static int SplitFilenames(const string str, vector<string> &filenames)
204{
205        int pos = 0;
206
207        while(1) {
208                int npos = (int)str.find(';', pos);
209               
210                if (npos < 0 || npos - pos < 1)
211                        break;
212                filenames.push_back(string(str, pos, npos - pos));
213                pos = npos + 1;
214        }
215       
216        filenames.push_back(string(str, pos, str.size() - pos));
217        return (int)filenames.size();
218}
219
220
221bool
222Preprocessor::LoadScene(const string filename)
223{
224        // use leaf nodes of the original spatial hierarchy as occludees
225        mSceneGraph = new SceneGraph;
226 
227        Parser *parser;
228        vector<string> filenames;
229        const int files = SplitFilenames(filename, filenames);
230        cout << "number of input files: " << files << endl;
231        bool result = false;
232
233        // root for different files
234        mSceneGraph->SetRoot(new SceneGraphNode());
235
236        // intel ray caster can only trace triangles
237        int rayCastMethod;
238        Environment::GetSingleton()->GetIntValue("Preprocessor.rayCastMethod", rayCastMethod);
239        vector<FaceParentInfo> *fi = (rayCastMethod == RayCaster::INTEL_RAYCASTER) ?
240                &mFaceParents : NULL;
241
242        if (files == 1) {
243               
244                if (strstr(filename.c_str(), ".x3d"))
245                  parser = new X3dParser;
246                else
247                  if (strstr(filename.c_str(), ".ply") || strstr(filename.c_str(), ".plb"))
248                        parser = new PlyParser;
249                  else if (strstr(filename.c_str(), ".obj"))
250                          parser = new ObjParser;
251                  else
252                          parser = new UnigraphicsParser;
253
254                cout << filename << endl;
255               
256                result = parser->ParseFile(
257                                filename,
258                                mSceneGraph->GetRoot(),
259                                mLoadMeshes,
260                                fi);
261                       
262                delete parser;
263
264        }
265        else {
266                vector<string>::const_iterator fit, fit_end = filenames.end();
267               
268                for (fit = filenames.begin(); fit != fit_end; ++ fit)
269                {
270                        const string filename = *fit;
271
272                        cout << "parsing file " << filename.c_str() << endl;
273                        if (strstr(filename.c_str(), ".x3d"))
274                                parser = new X3dParser;
275                        else
276                                parser = new UnigraphicsParser;
277
278                        SceneGraphNode *node = new SceneGraphNode();
279                        const bool success = parser->ParseFile(
280                                filename,
281                                node,
282                                mLoadMeshes,
283                                fi);
284
285                        if (success)
286                        {
287                                mSceneGraph->GetRoot()->mChildren.push_back(node);
288                                result = true; // at least one file parsed
289                        }
290
291                        delete parser;
292                }
293        }
294       
295        if (result)
296        {
297                // HACK
298                if (ADDITIONAL_GEOMETRY_HACK)
299                        AddGeometry(mSceneGraph);
300
301                mSceneGraph->AssignObjectIds();
302 
303                int intersectables, faces;
304                mSceneGraph->GetStatistics(intersectables, faces);
305 
306                cout<<filename<<" parsed successfully."<<endl;
307                cout<<"#NUM_OBJECTS (Total numner of objects)\n"<<intersectables<<endl;
308                cout<<"#NUM_FACES (Total numner of faces)\n"<<faces<<endl;
309                mSceneGraph->CollectObjects(&mObjects);
310                mSceneGraph->GetRoot()->UpdateBox();
311 
312                if (0)
313                {
314                        Exporter *exporter = Exporter::GetExporter("testload.x3d");
315                        if (exporter)
316                        {
317                                exporter->ExportGeometry(mObjects);
318                                delete exporter;
319                        }
320                }
321        }
322
323        return result;
324}
325
326bool
327Preprocessor::ExportPreprocessedData(const string filename)
328{
329        mViewCellsManager->ExportViewCells(filename, true, mObjects);
330        return true;
331}
332
333
334bool
335Preprocessor::PostProcessVisibility()
336{
337 
338  if (mApplyVisibilityFilter || mApplyVisibilitySpatialFilter) {
339        cout<<"Applying visibility filter ...";
340        cout<<"filter width = " << mVisibilityFilterWidth << endl;
341       
342        if (!mViewCellsManager)
343          return false;
344       
345        mViewCellsManager->ApplyFilter(mKdTree,
346                                                                   mApplyVisibilityFilter ? mVisibilityFilterWidth : -1.0f,
347                                                                   mApplyVisibilitySpatialFilter ? mVisibilityFilterWidth : -1.0f);
348        cout << "done." << endl;
349  }
350 
351  // export the preprocessed information to a file
352  if (mExportVisibility)
353  {
354          ExportPreprocessedData(mVisibilityFileName);
355  }
356
357  return true;
358}
359
360
361bool
362Preprocessor::BuildKdTree()
363{
364  mKdTree = new KdTree;
365
366  // add mesh instances of the scene graph to the root of the tree
367  KdLeaf *root = (KdLeaf *)mKdTree->GetRoot();
368       
369  mSceneGraph->CollectObjects(&root->mObjects);
370 
371  const long startTime = GetTime();
372  cout << "building kd tree ... " << endl;
373
374  mKdTree->Construct();
375
376  cout << "finished kd tree construction in " << TimeDiff(startTime, GetTime()) * 1e-3
377           << " secs " << endl;
378
379  return true;
380}
381
382
383void
384Preprocessor::KdTreeStatistics(ostream &s)
385{
386  s<<mKdTree->GetStatistics();
387}
388
389void
390Preprocessor::BspTreeStatistics(ostream &s)
391{
392        s << mBspTree->GetStatistics();
393}
394
395bool
396Preprocessor::Export( const string filename,
397                                          const bool scene,
398                                          const bool kdtree,
399                                          const bool bsptree
400                                          )
401{
402  Exporter *exporter = Exporter::GetExporter(filename);
403       
404  if (exporter) {
405    if (0 && scene)
406      exporter->ExportScene(mSceneGraph->GetRoot());
407
408    if (0 && kdtree) {
409      exporter->SetWireframe();
410      exporter->ExportKdTree(*mKdTree);
411    }
412
413        if (0 && bsptree) {
414                //exporter->SetWireframe();
415                exporter->ExportBspTree(*mBspTree);
416        }
417
418    delete exporter;
419    return true;
420  }
421
422  return false;
423}
424
425
426bool Preprocessor::PrepareViewCells()
427{
428        ///////
429        //-- parse view cells construction method
430        Environment::GetSingleton()->GetBoolValue("ViewCells.loadFromFile", mLoadViewCells);
431        char buf[100];
432       
433        if (mLoadViewCells)
434        {       
435                Environment::GetSingleton()->GetStringValue("ViewCells.filename", buf);
436                cout << "loading view cells from " << buf << endl;
437                mViewCellsManager = ViewCellsManager::LoadViewCells(buf, &mObjects, true);
438                if (!mViewCellsManager)
439                        return false;
440        }
441        else
442        {
443                // parse type of view cell container
444                Environment::GetSingleton()->GetStringValue("ViewCells.type", buf);             
445            mViewCellsManager = CreateViewCellsManager(buf);
446
447                // default view space is the extent of the scene
448                mViewCellsManager->SetViewSpaceBox(mSceneGraph->GetBox());
449        }
450       
451        ////////
452        //-- evaluation of render cost heuristics
453        float objRenderCost = 0, vcOverhead = 0, moveSpeed = 0;
454
455        Environment::GetSingleton()->GetFloatValue("Simulation.objRenderCost",objRenderCost);
456        Environment::GetSingleton()->GetFloatValue("Simulation.vcOverhead", vcOverhead);
457        Environment::GetSingleton()->GetFloatValue("Simulation.moveSpeed", moveSpeed);
458       
459        mRenderSimulator =
460                new RenderSimulator(mViewCellsManager, objRenderCost, vcOverhead, moveSpeed);
461
462        mViewCellsManager->SetRenderer(mRenderSimulator);
463
464
465        if (mUseGlRenderer || mUseGlDebugger)
466        {
467                // NOTE: render texture should be power of 2 and square
468                // renderer must be initialised
469                // $$matt
470//              renderer = new GlRendererBuffer(1024, 768, mSceneGraph, mViewCellsManager, mKdTree);
471                //              renderer->makeCurrent();
472               
473        }
474       
475        return true;
476}
477
478 
479bool Preprocessor::ConstructViewCells(const AxisAlignedBox3 &viewSpaceBox)
480{
481        mViewCellsManager->SetViewSpaceBox(viewSpaceBox);
482       
483        // construct view cells using it's own set of samples
484        mViewCellsManager->Construct(this);
485
486        // visualizations and statistics
487        Debug << "finished view cells:" << endl;
488        mViewCellsManager->PrintStatistics(Debug);
489           
490        return true;
491}
492
493
494HierarchyManager *Preprocessor::CreateHierarchyManager(const char *name)
495{
496        HierarchyManager *hierarchyManager;
497
498        if (strcmp(name, "osp") == 0)
499        {
500                Debug << "hierarchy manager: osp" << endl;
501                // HACK for testing if per kd evaluation works!!
502                const bool ishack = false;
503                if (ishack)
504                        hierarchyManager = new HierarchyManager(mKdTree);
505                else
506                        hierarchyManager = new HierarchyManager(HierarchyManager::KD_BASED_OBJ_SUBDIV);
507        }
508        else if (strcmp(name, "bvh") == 0)
509        {
510                Debug << "hierarchy manager: bvh" << endl;
511                hierarchyManager = new HierarchyManager(HierarchyManager::BV_BASED_OBJ_SUBDIV);
512        }
513        else // only view space partition
514        {
515                Debug << "hierarchy manager: obj" << endl;
516                hierarchyManager = new HierarchyManager(HierarchyManager::NO_OBJ_SUBDIV);
517        }
518
519        return hierarchyManager;
520}
521
522
523ViewCellsManager *Preprocessor::CreateViewCellsManager(const char *name)
524{
525        ViewCellsTree *vcTree = new ViewCellsTree;
526
527        if (strcmp(name, "kdTree") == 0)
528        {
529                mViewCellsManager = new KdViewCellsManager(vcTree, mKdTree);
530        }
531        else if (strcmp(name, "bspTree") == 0)
532        {
533                Debug << "view cell type: Bsp" << endl;
534
535                mBspTree = new BspTree();
536                mViewCellsManager = new BspViewCellsManager(vcTree, mBspTree);
537        }
538        else if (strcmp(name, "vspBspTree") == 0)
539        {
540                Debug << "view cell type: VspBsp" << endl;
541
542                mVspBspTree = new VspBspTree();
543                mViewCellsManager = new VspBspViewCellsManager(vcTree, mVspBspTree);
544        }
545        else if (strcmp(name, "vspOspTree") == 0)
546        {
547                Debug << "view cell type: VspOsp" << endl;
548                char buf[100];         
549                Environment::GetSingleton()->GetStringValue("Hierarchy.type", buf);     
550
551                HierarchyManager *mHierarchyManager = CreateHierarchyManager(buf);
552                mViewCellsManager = new VspOspViewCellsManager(vcTree, mHierarchyManager);
553        }
554        else if (strcmp(name, "sceneDependent") == 0) //TODO
555        {
556                Debug << "view cell type: Bsp" << endl;
557               
558                mBspTree = new BspTree();
559                mViewCellsManager = new BspViewCellsManager(vcTree, mBspTree);
560        }
561        else
562        {
563                cerr << "Wrong view cells type " << name << "!!!" << endl;
564                exit(1);
565        }
566
567        return mViewCellsManager;
568}
569
570
571// use ascii format to store rays
572#define USE_ASCII 0
573
574
575static inline bool ilt(Intersectable *obj1, Intersectable *obj2)
576{
577        return obj1->mId < obj2->mId;
578}
579
580
581bool Preprocessor::LoadKdTree(const string filename)
582{
583        mKdTree = new KdTree();
584        return mKdTree->LoadBinTree(filename.c_str(), mObjects);
585}
586
587
588bool Preprocessor::ExportKdTree(const string filename)
589{
590        return mKdTree->ExportBinTree(filename.c_str());
591}
592
593
594bool Preprocessor::LoadSamples(VssRayContainer &samples,
595                                                           ObjectContainer &objects) const
596{
597        std::stable_sort(objects.begin(), objects.end(), ilt);
598        char fileName[100];
599        Environment::GetSingleton()->GetStringValue("Preprocessor.samplesFilename", fileName);
600       
601    Vector3 origin, termination;
602        // HACK: needed only for lower_bound algorithm to find the
603        // intersected objects
604        MeshInstance sObj(NULL);
605        MeshInstance tObj(NULL);
606
607#if USE_ASCII
608        ifstream samplesIn(fileName);
609        if (!samplesIn.is_open())
610                return false;
611
612        string buf;
613        while (!(getline(samplesIn, buf)).eof())
614        {
615                sscanf(buf.c_str(), "%f %f %f %f %f %f %d %d",
616                           &origin.x, &origin.y, &origin.z,
617                           &termination.x, &termination.y, &termination.z,
618                           &(sObj.mId), &(tObj.mId));
619               
620                Intersectable *sourceObj = NULL;
621                Intersectable *termObj = NULL;
622               
623                if (sObj.mId >= 0)
624                {
625                        ObjectContainer::iterator oit =
626                                lower_bound(objects.begin(), objects.end(), &sObj, ilt);
627                        sourceObj = *oit;
628                }
629               
630                if (tObj.mId >= 0)
631                {
632                        ObjectContainer::iterator oit =
633                                lower_bound(objects.begin(), objects.end(), &tObj, ilt);
634                        termObj = *oit;
635                }
636
637                samples.push_back(new VssRay(origin, termination, sourceObj, termObj));
638        }
639#else
640        ifstream samplesIn(fileName, ios::binary);
641        if (!samplesIn.is_open())
642                return false;
643
644        while (1)
645        {
646                 samplesIn.read(reinterpret_cast<char *>(&origin), sizeof(Vector3));
647                 samplesIn.read(reinterpret_cast<char *>(&termination), sizeof(Vector3));
648                 samplesIn.read(reinterpret_cast<char *>(&(sObj.mId)), sizeof(int));
649                 samplesIn.read(reinterpret_cast<char *>(&(tObj.mId)), sizeof(int));
650               
651                 if (samplesIn.eof())
652                        break;
653
654                Intersectable *sourceObj = NULL;
655                Intersectable *termObj = NULL;
656               
657                if (sObj.mId >= 0)
658                {
659                        ObjectContainer::iterator oit =
660                                lower_bound(objects.begin(), objects.end(), &sObj, ilt);
661                        sourceObj = *oit;
662                }
663               
664                if (tObj.mId >= 0)
665                {
666                        ObjectContainer::iterator oit =
667                                lower_bound(objects.begin(), objects.end(), &tObj, ilt);
668                        termObj = *oit;
669                }
670
671                samples.push_back(new VssRay(origin, termination, sourceObj, termObj));
672        }
673
674#endif
675        samplesIn.close();
676
677        return true;
678}
679
680
681bool Preprocessor::ExportSamples(const VssRayContainer &samples) const
682{
683        char fileName[100];
684        Environment::GetSingleton()->GetStringValue("Preprocessor.samplesFilename", fileName);
685       
686
687        VssRayContainer::const_iterator it, it_end = samples.end();
688       
689#if USE_ASCII
690        ofstream samplesOut(fileName);
691        if (!samplesOut.is_open())
692                return false;
693
694        for (it = samples.begin(); it != it_end; ++ it)
695        {
696                VssRay *ray = *it;
697                int sourceid = ray->mOriginObject ? ray->mOriginObject->mId : -1;               
698                int termid = ray->mTerminationObject ? ray->mTerminationObject->mId : -1;       
699
700                samplesOut << ray->GetOrigin().x << " " << ray->GetOrigin().y << " " << ray->GetOrigin().z << " "
701                                   << ray->GetTermination().x << " " << ray->GetTermination().y << " " << ray->GetTermination().z << " "
702                                   << sourceid << " " << termid << "\n";
703        }
704#else
705        ofstream samplesOut(fileName, ios::binary);
706        if (!samplesOut.is_open())
707                return false;
708
709        for (it = samples.begin(); it != it_end; ++ it)
710        {       
711                VssRay *ray = *it;
712                Vector3 origin(ray->GetOrigin());
713                Vector3 termination(ray->GetTermination());
714               
715                int sourceid = ray->mOriginObject ? ray->mOriginObject->mId : -1;               
716                int termid = ray->mTerminationObject ? ray->mTerminationObject->mId : -1;               
717
718                samplesOut.write(reinterpret_cast<char *>(&origin), sizeof(Vector3));
719                samplesOut.write(reinterpret_cast<char *>(&termination), sizeof(Vector3));
720                samplesOut.write(reinterpret_cast<char *>(&sourceid), sizeof(int));
721                samplesOut.write(reinterpret_cast<char *>(&termid), sizeof(int));
722    }
723#endif
724        samplesOut.close();
725
726        return true;
727}
728
729bool Preprocessor::GenerateRays(const int number,
730                                                                const int sampleType,
731                                                                SimpleRayContainer &rays)
732{
733        const int startSize = (int)rays.size();
734        SamplingStrategy *strategy = GenerateSamplingStrategy(sampleType);
735
736        if (!strategy)
737        {
738                return false;
739        }
740
741        for (int i=0; (int)rays.size() - startSize < number; ++ i)
742        {
743                SimpleRay newRay;
744
745                if (strategy->GenerateSample(newRay))
746                {
747#if 1
748                        rays.AddRay(newRay);
749#else
750                        GenerateRayBundle(rays, newRay, 16, 0);
751#endif
752                }       
753        }
754
755        delete strategy;
756    return true;
757}
758
759
760SamplingStrategy *Preprocessor::GenerateSamplingStrategy(const int strategyId) const
761{
762        switch (strategyId)
763        {
764        case SamplingStrategy::OBJECT_BASED_DISTRIBUTION:
765                return new ObjectBasedDistribution(*this);
766        case SamplingStrategy::OBJECT_DIRECTION_BASED_DISTRIBUTION:
767                return new ObjectDirectionBasedDistribution(*this);
768        case SamplingStrategy::DIRECTION_BASED_DISTRIBUTION:
769                return new DirectionBasedDistribution(*this);
770        case SamplingStrategy::DIRECTION_BOX_BASED_DISTRIBUTION:
771                return new DirectionBoxBasedDistribution(*this);
772        case SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION:
773                return new SpatialBoxBasedDistribution(*this);
774        //case OBJECTS_INTERIOR_DISTRIBUTION:
775        //      return new ObjectsInteriorDistribution(*this);
776        default: // no valid strategy
777                Debug << "warning: no valid sampling strategy" << endl;
778                return NULL;
779        }
780
781        // should never come here
782        return NULL;
783}
784
785
786bool Preprocessor::InitRayCast(const string externKdTree, const string internkdtree)
787{
788        bool loadKdTree;
789        Environment::GetSingleton()->GetBoolValue("Preprocessor.loadKdTree", loadKdTree);
790       
791        if (!loadKdTree)
792        {       
793                //-- build new kd tree from scene geometry
794                BuildKdTree();
795                KdTreeStatistics(cout);
796        }
797        else
798        {
799                const long startTime = GetTime();
800                cout << "loading kd tree file " << internkdtree << " ... ";
801
802                if (!LoadKdTree(internkdtree))
803                {
804                        cout << "error loading kd tree with filename " << internkdtree << ", rebuilding it instead ..." << endl;
805
806                        BuildKdTree();
807                        KdTreeStatistics(cout);
808                }
809
810                cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
811
812                if (0)
813                {
814                        Exporter *exporter = Exporter::GetExporter("dummykd.x3d");
815                       
816                        if (exporter)
817                        {
818                                exporter->ExportKdTree(*mKdTree, true);
819                                delete exporter;
820                        }
821                }
822        }
823
824        int rayCastMethod;
825        Environment::GetSingleton()->GetIntValue("Preprocessor.rayCastMethod", rayCastMethod);
826
827        if (rayCastMethod == 0)
828        {
829                mRayCaster = new InternalRayCaster(*this, mKdTree);
830                cout << "ray cast method: internal" << endl;
831        }
832        else
833        {
834#ifdef GTP_INTERNAL
835                mRayCaster = new IntelRayCaster(*this, externKdTree);
836                cout << "ray cast method: intel" << endl;
837#endif
838        }
839
840        return true;
841}
842
843
844void
845Preprocessor::CastRays(
846                                           SimpleRayContainer &rays,
847                                           VssRayContainer &vssRays,
848                                           const bool castDoubleRays
849                                           )
850{
851        const long t1 = GetTime();
852
853        for (int i = 0; i < (int)rays.size();)
854        {
855                if (i + 16 < (int)rays.size())
856                {
857                        mRayCaster->CastRays16(
858                                i,
859                                rays,                           
860                                vssRays,
861                                mViewCellsManager->GetViewSpaceBox(),
862                                castDoubleRays);
863                        i += 16;
864                }
865                else
866                {
867                        mRayCaster->CastRay(
868                                rays[i].mOrigin,
869                                rays[i].mDirection,
870                                rays[i].mPdf,
871                                vssRays,
872                                mViewCellsManager->GetViewSpaceBox(),
873                                castDoubleRays);
874                        i ++;
875                }
876        }
877
878#if DEBUB_RAYCAST
879        long t2 = GetTime();
880        if (i % 10000 == 0)
881                cout<<".";
882
883        if (castDoubleRays)
884                cout << 2 * rays.size() / (1e3f * TimeDiff(t1, t2)) << "M rays/s" << endl;
885        else
886                cout << rays.size() / (1e3f * TimeDiff(t1, t2)) << "M rays/s" << endl;
887#endif 
888}
889
890
891bool Preprocessor::GenerateRayBundle(SimpleRayContainer &rayBundle,                                                                     
892                                                                         const SimpleRay &mainRay,
893                                                                         const int number,
894                                                                         const int pertubType) const
895{
896        rayBundle.push_back(mainRay);
897
898        const float pertubOrigin = 10.0f;
899        const float pertubDir = 0.0f;
900
901        for (int i = 0; i < number - 1; ++ i)
902        {
903                Vector3 pertub;
904
905                pertub.x = RandomValue(0.0f, pertubDir);
906                pertub.y = RandomValue(0.0f, pertubDir);
907                pertub.z = RandomValue(0.0f, pertubDir);
908                const Vector3 newDir = mainRay.mDirection + pertub;
909                //const Vector3 newDir = mainRay.mDirection;
910
911                pertub.x = RandomValue(0.0f, pertubOrigin);
912                pertub.y = RandomValue(0.0f, pertubOrigin);
913                pertub.z = RandomValue(0.0f, pertubOrigin);
914                const Vector3 newOrigin = mainRay.mOrigin + pertub;
915                //const Vector3 newOrigin = mainRay.mOrigin;
916
917                rayBundle.push_back(SimpleRay(newOrigin, newDir, 0));
918        }
919
920        return true;
921}
922
923
924void Preprocessor::SetupRay(Ray &ray,
925                                                        const Vector3 &point,
926                                                        const Vector3 &direction
927                                                        ) const
928{
929        ray.Clear();
930        // do not store anything else then intersections at the ray
931        ray.Init(point, direction, Ray::LOCAL_RAY);
932}
933
934
935}
Note: See TracBrowser for help on using the repository browser.