source: GTP/trunk/Lib/Vis/Preprocessing/src/main.cpp @ 2048

Revision 2048, 10.1 KB checked in by mattausch, 17 years ago (diff)
Line 
1/*#ifdef GTP_INTERNAL
2#ifndef USE_QT
3#define USE_QT 1
4#else
5#define USE_QT 0
6#endif
7#endif
8*/
9
10#define USE_THREADS 0
11
12#ifdef UNICODE
13#undef UNICODE
14#endif
15
16#include <windows.h>
17#include <stdio.h>
18#include <crtdbg.h>
19
20#include "PreprocessorFactory.h"
21#include "Parser.h"
22#include "Environment.h"
23#include "MeshKdTree.h"
24#include "Preprocessor.h"
25#include "common.h"
26
27#include "PreprocessorThread.h"
28#include "ObjExporter.h"
29#include "SceneGraph.h"
30#include "GlobalLinesRenderer.h"
31
32#include "ViewCellsManager.h"
33
34#ifdef USE_QT 
35        #include "QtPreprocessorThread.h"
36        #include "QtGlViewer.h"
37        #include "QtGlRenderer.h"
38#else
39        #if USE_THREADS
40                #include "BoostPreprocessorThread.h"
41        #endif
42#endif
43
44#include "ResourceManager.h"
45#include "GlRenderer.h"
46
47
48#define USE_EXE_PATH false
49
50
51using namespace GtpVisibilityPreprocessor;
52
53//Preprocessor *preprocessor = NULL;
54GlRendererWidget *rendererWidget = NULL;
55//GlobalLinesRenderer *globalLinesRenderer = NULL;
56
57
58// DLL function signature
59typedef GlRendererWidget *(*importFunction)(Preprocessor *);
60
61
62
63void Cleanup()
64{
65        DEL_PTR(rendererWidget);
66        DEL_PTR(preprocessor);
67
68        Environment::DelSingleton();
69        MeshManager::DelSingleton();
70        MaterialManager::DelSingleton();
71}
72
73
74static string ReplaceSuffix(string filename, string a, string b)
75{
76        string result = filename;
77
78        int pos = (int)filename.rfind(a, (int)filename.size() - 1);
79        if (pos == filename.size() - a.size()) {
80                result.replace(pos, a.size(), b);
81        }
82        return result;
83}
84
85
86static int SplitFilenames(const string str, vector<string> &filenames)
87{
88        int pos = 0;
89
90        while(1) {
91                int npos = (int)str.find(';', pos);
92               
93                if (npos < 0 || npos - pos < 1)
94                        break;
95                filenames.push_back(string(str, pos, npos - pos));
96                pos = npos + 1;
97        }
98       
99        filenames.push_back(string(str, pos, str.size() - pos));
100        return (int)filenames.size();
101}
102
103
104static string GetInternFilename(const string &filename, const string newSuffix)
105{
106        vector<string> filenames;
107        const int files = SplitFilenames(filename, filenames);
108
109        vector<string>::const_iterator sit, sit_end = filenames.end();
110        string kdFilename;
111
112        int i = 0;
113        for (sit = filenames.begin(); sit != sit_end; ++ sit, ++ i)
114        {
115                string currentFile = *sit;
116                string strippedFilename;
117
118                if (i == 0)
119                {       
120                        strippedFilename = currentFile;
121                }
122                else
123                {
124                        char *str = StripPath(currentFile.c_str());
125                        strippedFilename = string(str);
126
127                        delete [] str;
128                }
129               
130                string suffix("_");
131
132                if (i == (int)filenames.size() - 1)
133                {
134                        suffix = newSuffix;
135                }
136
137                if (strstr(strippedFilename.c_str(), ".x3d"))
138                {
139                        kdFilename += ReplaceSuffix(strippedFilename, ".x3d", suffix);
140                }
141        else if (strstr(strippedFilename.c_str(), ".dat"))
142                {
143                        kdFilename += ReplaceSuffix(strippedFilename, ".dat", suffix);
144                }
145                else if (strstr(strippedFilename.c_str(), ".obj"))
146                {
147                        kdFilename += ReplaceSuffix(strippedFilename, ".obj", suffix);
148                }
149                else
150                {
151                        cerr << "Error: Currently unsupported format for kd, filename " << currentFile << endl;
152                }
153        }
154
155        //cout << "kdfilename: " << kdFilename << endl;
156        return kdFilename;
157}
158
159
160int
161main(int argc, char **argv)
162{
163        //Now just call this function at the start of your program and if you're
164        //compiling in debug mode (F5), any leaks will be displayed in the Output
165        //window when the program shuts down. If you're not in debug mode this will
166        //be ignored. Use it as you will!
167        //note: from GDNet Direct [3.8.04 - 3.14.04] void detectMemoryLeaks() {
168#if 1
169  _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF|_CRTDBG_ALLOC_MEM_DF);
170  _CrtSetReportMode(_CRT_ASSERT,_CRTDBG_MODE_FILE);
171  _CrtSetReportFile(_CRT_ASSERT,_CRTDBG_FILE_STDERR);
172#endif
173
174        int returnCode = 0;
175
176        InitTiming();
177        Debug.open("debug.log");
178
179#if 0
180        cout<<"Allocating 1.5GB..."<<endl;
181
182       
183        for (int i=0; i < 1000; i++) {
184          void *p = malloc(1250000000);
185          if (p != NULL) {
186                cout<<"success"<<(i+1)*1000<<"MB"<<endl;
187          }
188          else {
189                cout<<"fail"<<endl;
190                exit(1);
191          }
192        }
193#endif
194       
195        Environment::GetSingleton()->Parse(argc, argv, USE_EXE_PATH);
196        MeshKdTree::ParseEnvironment();
197
198        char buff[128];
199        Environment::GetSingleton()->GetStringValue("Preprocessor.type", buff);
200        string preprocessorType(buff);
201
202        if (!(preprocessor = PreprocessorFactory::CreatePreprocessor(preprocessorType)))
203        {
204                Environment::DelSingleton();
205                cerr << "Unknown preprocessor type" << endl;
206                exit(1);
207        }
208
209
210        Environment::GetSingleton()->GetStringValue("Scene.filename", buff);
211        string filename(buff);
212       
213        const string externKdTree = ReplaceSuffix(filename, ".obj", ".kdf");
214        const string internKdTree = GetInternFilename(filename, preprocessor->mLoadMeshes ? ".kdm" : ".kdt");
215
216        if (preprocessor->InitRayCast(externKdTree, internKdTree))
217        {
218                cout << "ray casting initialized!" << endl;
219        }
220        else
221        {
222                cout << "ray casting initialization failed!" << endl;
223                Cleanup();
224                exit(1);
225        }
226
227
228        /////////////
229        //-- load scene
230
231        if (!preprocessor->LoadScene(filename))
232        {
233                cout << "loading file " << filename << " failed" << endl;
234                Cleanup();
235                exit(1);
236        }
237       
238        ////////////
239        //-- initialize external ray caster
240
241        if (preprocessor->LoadInternKdTree(internKdTree))
242        {
243                cout << "intern kd tree loaded!" << endl;
244        }
245        else
246        {
247                cout << "loading intern kd tree failed!" << endl;
248                Cleanup();
249                exit(1);
250        }
251
252        // export objects as obj
253        if (preprocessor->mExportObj)
254        {
255                if (strstr(filename.c_str(), ".obj"))
256                {
257                        cerr << "already in obj format" << endl;
258                        if (0)  preprocessor->ExportObj("test.obj", preprocessor->mObjects);
259                }
260                else
261                {
262                        const string objname = GetInternFilename(filename, ".obj");
263
264                        cout << "exporting scene to " << objname << endl;
265                        bool success = preprocessor->ExportObj(objname, preprocessor->mObjects);
266
267                        if (success)
268                        {
269                                cout << "finished exporting obj" << endl;
270                        }
271                        else
272                        {
273                                cerr << "error exporting " << objname << endl;
274                        }
275                }
276        }
277       
278        // parse view cells related options
279        if (!preprocessor->PrepareViewCells())
280        {
281                cerr << "error: view cells could not be loaded" << endl;
282
283                Cleanup();
284                exit(1);
285        }
286
287        string viewCellPointsFile;
288
289        if (strstr(filename.c_str(), ".obj"))
290                viewCellPointsFile = ReplaceSuffix(filename, ".obj", ".vc");
291        else if (strstr(filename.c_str(), ".dat"))
292                viewCellPointsFile = ReplaceSuffix(filename, ".dat", ".vc");
293        else if (strstr(filename.c_str(), ".x3d"))
294                viewCellPointsFile = ReplaceSuffix(filename, ".x3d", ".vc");
295
296        bool importRandomViewCells;
297        Environment::GetSingleton()->GetBoolValue("ViewCells.importRandomViewCells",
298                                                                                           importRandomViewCells);
299
300        if (importRandomViewCells)
301        {
302                cout << "importing random view cells" << endl;
303                preprocessor->mViewCellsManager->ImportRandomViewCells(viewCellPointsFile);
304                cout << "finished" << endl;
305        }
306
307        bool useHwGlobalLines;
308        Environment::GetSingleton()->GetBoolValue("Preprocessor.useHwGlobalLines",
309                                                                                           useHwGlobalLines);
310
311        if (useHwGlobalLines)
312                preprocessor->PrepareHwGlobalLines();
313
314        // create a preprocessor thread (note: capsulates calls to boost fuctions!)
315        PreprocessorThread *pt = NULL;
316
317#ifdef TRY_GLOBAL_LINES
318       
319        preprocessor->PrepareHwGlobalLines();
320        globalLinesRenderer->Run();
321
322#else
323
324#ifdef USE_QT
325       
326        // create a qt application first (must be created before any opengl widget ...)
327        QApplication *app = new QApplication(argc, NULL);
328
329        pt = new QtPreprocessorThread(preprocessor);
330
331#else
332
333        //#if USE_THREADS
334        //      pt = new BoostPreprocessorThread(preprocessor);
335        //#else
336                // use a dummy thread
337                pt = new DummyPreprocessorThread(preprocessor);
338        //#endif
339#endif
340
341        preprocessor->SetThread(pt);
342
343        bool guiSupported = false;
344       
345        if (preprocessor->mUseGlRenderer || preprocessor->mUseGlDebugger)
346        {
347#ifdef USE_QT
348                cout << "using gl widget" << endl;
349                // create and run the preprocessor application in a parallel thread
350               
351                pt->InitThread();
352                pt->RunThread();
353
354                // display the render widget
355                if (!rendererWidget)
356                {
357                        if (!QGLFormat::hasOpenGL() || !QGLPixelBuffer::hasOpenGLPbuffers()) {
358                                QMessageBox::information(0, "OpenGL pbuffers",
359                                        "This system does not support OpenGL/pbuffers.",
360                                        QMessageBox::Ok);
361                                return NULL;
362                        }
363
364                        rendererWidget =
365                                new QtGlRendererWidget(preprocessor->mSceneGraph,
366                                                                           preprocessor->mViewCellsManager,
367                                                                           preprocessor->mKdTree);
368
369                        rendererWidget->Show();
370
371                        QtGlViewer *viewer =
372                                new QtGlViewer(NULL, (QtGlRendererWidget *)rendererWidget);
373
374                        viewer->show();
375                        guiSupported = true;
376                }
377
378                int frames;
379                Environment::GetSingleton()->GetIntValue("Preprocessor.pvsRenderErrorSamples", frames);
380               
381                if (1)//frames)
382                {
383                        // NOTE: render texture should be power of 2 and square
384                        // renderer must be initialised
385                        // $$matt
386                        preprocessor->renderer =
387                                new QtGlRendererBuffer(1024, 1024,
388                                                                           preprocessor->mSceneGraph,
389                                                                           preprocessor->mViewCellsManager,
390                                                                           preprocessor->mKdTree);
391                }
392
393                bool exportRandomViewCells;
394                Environment::GetSingleton()->GetBoolValue("ViewCells.exportRandomViewCells",
395                                                                                                  exportRandomViewCells);
396
397                if (exportRandomViewCells)
398                {
399                        cout << "exporting random view cells" << endl;
400                        preprocessor->mViewCellsManager->ExportRandomViewCells(viewCellPointsFile);
401                        cout << "finished" << endl;
402                }
403
404                /*bool evaluatePixelError;
405                Environment::GetSingleton()->GetBoolValue("Preprocessor.evaluatePixelError",  evaluatePixelError);
406
407                if (evaluatePixelError)
408                {
409                        cout << "evaluating pixel error" << endl;
410                        preprocessor->ComputeRenderError();
411                }*/
412
413                qApp->exec();
414#endif
415        }
416
417        // no gui available
418        if (!guiSupported)
419        {
420                if (preprocessor->mUseGlRenderer || preprocessor->mUseGlDebugger)
421                        cout << "warning: gui not supported!" << endl;
422               
423                preprocessor->mUseGlRenderer = false;
424                preprocessor->mUseGlDebugger = false;
425        }
426
427        if (!(preprocessor->mUseGlRenderer || preprocessor->mUseGlDebugger))
428        {
429                cout << "executing main thread" << endl;
430                // just call the mail method -> will be executed in the main thread
431                pt->Main();
432        }       
433#endif
434
435        // release memory
436        Cleanup();
437       
438        delete pt;
439
440        return returnCode;
441}
442
Note: See TracBrowser for help on using the repository browser.