source: trunk/VUT/GtpVisibilityPreprocessor/src/Preprocessor.cpp @ 577

Revision 577, 12.0 KB checked in by mattausch, 19 years ago (diff)

fixed loading function: the view cell manager is chosen depending on
the type in the file. the view space box is saved with the file

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 "VspKdTree.h"
12#include "RenderSimulator.h"
13#include "GlRenderer.h"
14
15Preprocessor *preprocessor;
16
17Preprocessor::Preprocessor():
18mKdTree(NULL),
19mBspTree(NULL),
20mVspKdTree(NULL),
21mVspBspTree(NULL),
22mViewCellsManager(NULL)
23{
24  environment->GetBoolValue("Preprocessor.useGlRenderer", mUseGlRenderer);
25 
26  // renderer will be constructed when the scene graph and viewcell manager will be known
27  renderer = NULL;
28 
29  environment->GetBoolValue("Preprocessor.useGlDebugger", mUseGlDebugger);
30}
31
32
33Preprocessor::~Preprocessor()
34{
35  Debug<<"Deleting view cells manager...\n";
36  DEL_PTR(mViewCellsManager);
37  Debug<<"done.\n";
38  Debug<<"Deleting bsp tree...\n";
39  DEL_PTR(mBspTree);
40  Debug<<"done.\n";
41  Debug<<"Deleting kd tree...\n";
42  DEL_PTR(mKdTree);
43  Debug<<"done.\n";
44  Debug<<"Deleting vspkd tree...\n";
45  DEL_PTR(mVspKdTree);
46  Debug<<"done.\n";
47  Debug<<"Deleting vspbsp tree...\n";
48  DEL_PTR(mVspBspTree);
49  Debug<<"done.\n";
50}
51
52int
53SplitFilenames(const string str, vector<string> &filenames)
54{
55        int pos = 0;
56
57        while(1) {
58                int npos = (int)str.find(';', pos);
59               
60                if (npos < 0 || npos - pos < 1)
61                        break;
62                filenames.push_back(string(str, pos, npos - pos));
63                pos = npos + 1;
64        }
65       
66        filenames.push_back(string(str, pos, str.size() - pos));
67        return (int)filenames.size();
68}
69
70bool
71Preprocessor::LoadScene(const string filename)
72{
73        // use leaf nodes of the original spatial hiearrchy as occludees
74        mSceneGraph = new SceneGraph;
75 
76        Parser *parser;
77        vector<string> filenames;
78        int files = SplitFilenames(filename, filenames);
79        cout<<files<<endl;
80        bool result = false;
81        if (files == 1) {
82               
83                if (strstr(filename.c_str(), ".x3d"))
84                        parser = new X3dParser;
85                else
86                        parser = new UnigraphicsParser;
87
88                cout<<filename<<endl;
89                result = parser->ParseFile(filename, &mSceneGraph->mRoot);
90
91                delete parser;
92
93        } else {
94                // root for different files
95                mSceneGraph->mRoot = new SceneGraphNode;
96                for (int i= 0; i < filenames.size(); i++) {
97                        if (strstr(filenames[i].c_str(), ".x3d"))
98                                parser = new X3dParser;
99                        else
100                                parser = new UnigraphicsParser;
101                       
102                        SceneGraphNode *node;
103                        if (parser->ParseFile(filenames[i], &node)) {
104                                mSceneGraph->mRoot->mChildren.push_back(node);
105                                // at least one file parsed
106                                result = true;
107                        }
108                        delete parser;
109                }
110        }
111       
112
113        if (result) {
114         
115          mSceneGraph->AssignObjectIds();
116          int intersectables, faces;
117          mSceneGraph->GetStatistics(intersectables, faces);
118          cout<<filename<<" parsed successfully."<<endl;
119          cout<<"#NUM_OBJECTS (Total numner of objects)\n"<<intersectables<<endl;
120          cout<<"#NUM_FACES (Total numner of faces)\n"<<faces<<endl;
121          mSceneGraph->CollectObjects(&mObjects);
122          mSceneGraph->mRoot->UpdateBox();
123        }
124       
125       
126        return result;
127}
128
129bool
130Preprocessor::ExportPreprocessedData(const string filename)
131{
132  return false;
133}
134
135bool
136Preprocessor::BuildKdTree()
137{
138  mKdTree = new KdTree;
139  // add mesh instances of the scene graph to the root of the tree
140  KdLeaf *root = (KdLeaf *)mKdTree->GetRoot();
141  mSceneGraph->CollectObjects(&root->mObjects);
142 
143  mKdTree->Construct();
144  return true;
145}
146
147void
148Preprocessor::KdTreeStatistics(ostream &s)
149{
150  s<<mKdTree->GetStatistics();
151}
152
153void
154Preprocessor::BspTreeStatistics(ostream &s)
155{
156        s << mBspTree->GetStatistics();
157}
158
159bool
160Preprocessor::Export( const string filename,
161                                          const bool scene,
162                                          const bool kdtree,
163                                          const bool bsptree
164                                          )
165{
166  Exporter *exporter = Exporter::GetExporter(filename);
167       
168  if (exporter) {
169    if (scene)
170      exporter->ExportScene(mSceneGraph->mRoot);
171
172    if (kdtree) {
173      exporter->SetWireframe();
174      exporter->ExportKdTree(*mKdTree);
175    }
176
177        if (bsptree) {
178                //exporter->SetWireframe();
179                exporter->ExportBspTree(*mBspTree);
180        }
181
182    delete exporter;
183    return true;
184  }
185
186  return false;
187}
188
189
190bool Preprocessor::PrepareViewCells()
191{
192        //-- parse view cells construction method
193        environment->GetBoolValue("ViewCells.loadFromFile", mLoadViewCells);
194        char buf[100];
195       
196        if (mLoadViewCells)
197        {
198                environment->GetStringValue("ViewCells.filename", buf);
199                mViewCellsManager = ViewCellsManager::LoadViewCells(buf, &mObjects);
200        }
201        else
202        {
203                //-- parse type of view cell container
204                char viewCellsStr[64];
205                environment->GetStringValue("ViewCells.type", viewCellsStr);
206            mViewCellsManager = CreateViewCellsManager(viewCellsStr);
207        }
208
209        float objRenderCost = 0, vcOverhead = 0, moveSpeed = 0;
210
211        environment->GetFloatValue("Simulation.objRenderCost",objRenderCost);
212        environment->GetFloatValue("Simulation.vcOverhead", vcOverhead);
213        environment->GetFloatValue("Simulation.moveSpeed", moveSpeed);
214
215        mRenderSimulator =
216                new RenderSimulator(mViewCellsManager, objRenderCost, vcOverhead, moveSpeed);
217
218        mViewCellsManager->SetRenderer(mRenderSimulator);
219
220
221        if (mUseGlRenderer || mUseGlDebugger)
222        {
223                // NOTE: render texture should be power of 2 and square
224                // renderer must be initialised
225                renderer = new GlRendererBuffer(1024, 768, mSceneGraph, mViewCellsManager, mKdTree);
226                //              renderer->makeCurrent();
227        }
228
229
230        environment->GetBoolValue("Preprocessor.detectEmptyViewSpace", mDetectEmptyViewSpace);
231       
232        return true;
233}
234
235
236ViewCellsManager *Preprocessor::CreateViewCellsManager(const char *name)
237{
238        if (strcmp(name, "kdTree") == 0)
239        {
240                mViewCellsManager = new KdViewCellsManager(mKdTree);
241        }
242        else if (strcmp(name, "bspTree") == 0)
243        {
244                Debug << "view cell type: Bsp" << endl;
245
246                mBspTree = new BspTree();
247                mViewCellsManager = new BspViewCellsManager(mBspTree);
248        }
249        else if (strcmp(name, "vspBspTree") == 0)
250        {
251                Debug << "view cell type: VspBsp" << endl;
252
253                mVspBspTree = new VspBspTree();
254                mViewCellsManager = new VspBspViewCellsManager(mVspBspTree);
255        }
256        else if (strcmp(name, "vspKdTree") == 0)
257        {
258                mVspKdTree = new VspKdTree();           
259       
260                mViewCellsManager = new VspKdViewCellsManager(mVspKdTree);
261        }
262        else if (strcmp(name, "sceneDependent") == 0)
263        {
264                //TODO
265                mBspTree = new BspTree();
266
267                Debug << "view cell type: Bsp" << endl;
268               
269                mViewCellsManager = new BspViewCellsManager(mBspTree);
270        }
271        else
272        {
273                cerr<<"Wrong view cells type" << name << endl;
274                exit(1);
275        }
276
277        return mViewCellsManager;
278}
279
280
281// use ascii format to store rays
282#define USE_ASCII 0
283
284
285inline bool ilt(Intersectable *obj1, Intersectable *obj2)
286{
287        return obj1->mId < obj2->mId;
288}
289
290
291bool Preprocessor::LoadSamples(VssRayContainer &samples,
292                                                           ObjectContainer &objects) const
293{
294        std::stable_sort(objects.begin(), objects.end(), ilt);
295        char fileName[100];
296        environment->GetStringValue("Preprocessor.samplesFilename", fileName);
297       
298    Vector3 origin, termination;
299        // HACK: needed only for lower_bound algorithm to find the
300        // intersected objects
301        MeshInstance sObj(NULL);
302        MeshInstance tObj(NULL);
303
304#if USE_ASCII
305        ifstream samplesIn(fileName, ios::binary);
306        if (!samplesIn.is_open())
307                return false;
308
309        string buf;
310        while (!(getline(samplesIn, buf)).eof())
311        {
312                sscanf(buf.c_str(), "%f %f %f %f %f %f %d %d",
313                           &origin.x, &origin.y, &origin.z,
314                           &termination.x, &termination.y, &termination.z,
315                           &(sObj.mId), &(tObj.mId));
316               
317                Intersectable *sourceObj = NULL;
318                Intersectable *termObj = NULL;
319               
320                if (sObj.mId >= 0)
321                {
322                        ObjectContainer::iterator oit =
323                                lower_bound(objects.begin(), objects.end(), &sObj, ilt);
324                        sourceObj = *oit;
325                }
326               
327                if (tObj.mId >= 0)
328                {
329                        ObjectContainer::iterator oit =
330                                lower_bound(objects.begin(), objects.end(), &tObj, ilt);
331                        termObj = *oit;
332                }
333
334                samples.push_back(new VssRay(origin, termination, sourceObj, termObj));
335        }
336#else
337        ifstream samplesIn(fileName, ios::binary);
338        if (!samplesIn.is_open())
339                return false;
340
341        while (1)
342        {
343                 samplesIn.read(reinterpret_cast<char *>(&origin), sizeof(Vector3));
344                 samplesIn.read(reinterpret_cast<char *>(&termination), sizeof(Vector3));
345                 samplesIn.read(reinterpret_cast<char *>(&(sObj.mId)), sizeof(int));
346                 samplesIn.read(reinterpret_cast<char *>(&(tObj.mId)), sizeof(int));
347               
348                 if (samplesIn.eof())
349                        break;
350
351                Intersectable *sourceObj = NULL;
352                Intersectable *termObj = NULL;
353               
354                if (sObj.mId >= 0)
355                {
356                        ObjectContainer::iterator oit =
357                                lower_bound(objects.begin(), objects.end(), &sObj, ilt);
358                        sourceObj = *oit;
359                }
360               
361                if (tObj.mId >= 0)
362                {
363                        ObjectContainer::iterator oit =
364                                lower_bound(objects.begin(), objects.end(), &tObj, ilt);
365                        termObj = *oit;
366                }
367
368                samples.push_back(new VssRay(origin, termination, sourceObj, termObj));
369        }
370
371#endif
372        samplesIn.close();
373
374        return true;
375}
376
377
378bool Preprocessor::ExportSamples(const VssRayContainer &samples) const
379{
380        char fileName[100];
381        environment->GetStringValue("Preprocessor.samplesFilename", fileName);
382       
383
384        VssRayContainer::const_iterator it, it_end = samples.end();
385       
386#if USE_ASCII
387        ofstream samplesOut(fileName);
388        if (!samplesOut.is_open())
389                return false;
390
391        for (it = samples.begin(); it != it_end; ++ it)
392        {
393                VssRay *ray = *it;
394                int sourceid = ray->mOriginObject ? ray->mOriginObject->mId : -1;               
395                int termid = ray->mTerminationObject ? ray->mTerminationObject->mId : -1;       
396
397                samplesOut << ray->GetOrigin().x << " " << ray->GetOrigin().y << " " << ray->GetOrigin().z << " "
398                                   << ray->GetTermination().x << " " << ray->GetTermination().y << " " << ray->GetTermination().z << " "
399                                   << sourceid << " " << termid << "\n";
400        }
401#else
402        ofstream samplesOut(fileName, ios::binary);
403        if (!samplesOut.is_open())
404                return false;
405
406        for (it = samples.begin(); it != it_end; ++ it)
407        {       
408                VssRay *ray = *it;
409                Vector3 origin(ray->GetOrigin());
410                Vector3 termination(ray->GetTermination());
411               
412                int sourceid = ray->mOriginObject ? ray->mOriginObject->mId : -1;               
413                int termid = ray->mTerminationObject ? ray->mTerminationObject->mId : -1;               
414
415                samplesOut.write(reinterpret_cast<char *>(&origin), sizeof(Vector3));
416                samplesOut.write(reinterpret_cast<char *>(&termination), sizeof(Vector3));
417                samplesOut.write(reinterpret_cast<char *>(&sourceid), sizeof(int));
418                samplesOut.write(reinterpret_cast<char *>(&termid), sizeof(int));
419    }
420#endif
421        samplesOut.close();
422        return true;
423}
424
425
426
427bool
428Preprocessor::GenerateRays(
429                                                   const int number,
430                                                   const int sampleType,
431                                                   SimpleRayContainer &rays
432                                                   )
433{
434  Vector3 origin, direction;
435  int startSize = rays.size();
436  for (int i=0; rays.size() - startSize  < number; i++) {
437        // now get the direction
438        switch (sampleType) {
439        case OBJECT_BASED_DISTRIBUTION: {
440          mViewCellsManager->GetViewPoint(origin);
441          Vector3 point;
442          Vector3 normal;
443          int i = RandomValue(0, mObjects.size() - 1);
444          Intersectable *object = mObjects[i];
445          object->GetRandomSurfacePoint(point, normal);
446          direction = point - origin;
447        }
448          break;
449        case OBJECT_DIRECTION_BASED_DISTRIBUTION: {
450          int i = RandomValue(0, mObjects.size() - 1);
451          Intersectable *object = mObjects[i];
452          Vector3 normal;
453          object->GetRandomSurfacePoint(origin, normal);
454          direction = UniformRandomVector(normal);
455          origin += 0.1f*direction;
456        }
457          break;
458        case DIRECTION_BASED_DISTRIBUTION:
459          mViewCellsManager->GetViewPoint(origin);
460          direction = UniformRandomVector();
461          break;
462        case DIRECTION_BOX_BASED_DISTRIBUTION: {
463          mViewCellsManager->GetViewPoint(origin);
464          float alpha = RandomValue(0.0f, 2*M_PI);
465          float beta = RandomValue(-M_PI/2, M_PI/2);
466          direction = VssRay::GetDirection(alpha, beta);
467          break;
468        }
469        case SPATIAL_BOX_BASED_DISTRIBUTION:
470          mViewCellsManager->GetViewPoint(origin);
471          direction = mKdTree->GetBox().GetRandomPoint() - origin;
472          break;
473        default:
474          // unsuported distribution type
475          return false;
476        }
477        // $$ jb the pdf is yet not correct for all sampling methods!
478        float pdf = 1.0f;
479        float c = Magnitude(direction);
480        if (c > Limits::Small) {
481          direction*=1.0f/c;
482          rays.AddRay(SimpleRay(origin, direction, pdf));
483        }
484  }
485  return true;
486}
Note: See TracBrowser for help on using the repository browser.