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

#ifdef GTP_INTERNAL
//#define USE_QT 0
#endif
//#define USE_QT 0
#define USE_THREADS 1

#ifdef UNICODE
#undef UNICODE
#endif

#include <windows.h>
#include <stdio.h>
#include <crtdbg.h>

#include "SamplingPreprocessor.h"
#include "VssPreprocessor.h"
#include "RssPreprocessor.h"
#include "ExactPreprocessor.h"
#include "Parser.h"
#include "UnigraphicsParser.h"
#include "X3dParser.h"
#include "Environment.h"
#include "Camera.h"
#include "MeshKdTree.h"
#include "Exporter.h"
#include "ViewCell.h"
#include "SceneGraph.h"

#if USE_THREADS && !USE_QT
#include "BoostPreprocessorThread.h"
#endif

#include "RenderSampler.h"
#include "ResourceManager.h"
#include "GlRenderer.h"

#if USE_QT
#include "QtPreprocessorThread.h"
#include "QtGlRenderer.h"
#endif

#define USE_EXE_PATH false


using namespace GtpVisibilityPreprocessor;

Preprocessor *preprocessor = NULL;
GlRendererWidget *rendererWidget = NULL;

// DLL function signature
typedef GlRendererWidget *(*importFunction)(Preprocessor *);




void Cleanup()
{
        DEL_PTR(rendererWidget);
        DEL_PTR(preprocessor);

        Environment::DelSingleton();
        MeshManager::DelSingleton();
        MaterialManager::DelSingleton();
}




string ReplaceSuffix(string filename,
                                         string a,
                                         string b)
{
  string result = filename;

  int pos = (int)filename.rfind(a, (int)filename.size() - 1);
  if (pos == filename.size() - a.size()) {
        result.replace(pos, a.size(), b);
  }
  return result;
}

int
main(int argc, char **argv)
{

        //Now just call this function at the start of your program and if you're
        //compiling in debug mode (F5), any leaks will be displayed in the Output
        //window when the program shuts down. If you're not in debug mode this will
        //be ignored. Use it as you will!
        //note: from GDNet Direct [3.8.04 - 3.14.04] void detectMemoryLeaks() {
#if 0
  _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF|_CRTDBG_ALLOC_MEM_DF);
  _CrtSetReportMode(_CRT_ASSERT,_CRTDBG_MODE_FILE);
  _CrtSetReportFile(_CRT_ASSERT,_CRTDBG_FILE_STDERR); 
#endif

        int returnCode = 0;
        
        InitTiming();

        Debug.open("debug.log");
  
        Environment::GetSingleton()->Parse(argc, argv, USE_EXE_PATH);
        MeshKdTree::ParseEnvironment();

        
        char buff[128];
        Environment::GetSingleton()->GetStringValue("Preprocessor.type", buff);
        string preprocessorType(buff);

        if (preprocessorType == "vss")
        {
                preprocessor = new VssPreprocessor();
        }
        else
        {
                if (preprocessorType == "rss")
                {
                        preprocessor = new RssPreprocessor();
                }
                else
                {
                        if (preprocessorType == "exact")
                        {
                                preprocessor = new ExactPreprocessor();
                        }
                        else
                        {
                                if (preprocessorType == "sampling")
                                {
                                        preprocessor = new SamplingPreprocessor();
                                }
                                else
                                {       
                                        if (preprocessorType == "render")
                                        {
                                                preprocessor = new RenderSampler();
                                        }
                                        else 
                                        {
                                                Environment::DelSingleton();
                                                cerr<<"Unknown preprocessor type"<<endl;
                                                Debug<<"Unknown preprocessor type"<<endl;
                                                exit(1);
                                        }
                                }
                        }
                }
        }


        /////////////
        //-- load scene 

        Environment::GetSingleton()->GetStringValue("Scene.filename", buff);
        string filename(buff);

        if (!preprocessor->LoadScene(filename))
        {
                cout << "loading file " << filename << " failed" << endl;
                Cleanup();
                exit(1);
        }


        string externKdTree = ReplaceSuffix(filename, ".obj", ".kdf");
        char internKdTree[100];
        Environment::GetSingleton()->GetStringValue("Preprocessor.kdTreeFilename", internKdTree);

        //-- initialize external ray casters
        if (preprocessor->InitRayCast(externKdTree, internKdTree))
        {
                cout << "ray casting initialized!" << endl;
        }
        else
        {
                cout << "ray casting initialization failed" << endl;
                Cleanup();
                exit(1);
        }

        // export kd tree?
        bool exportKdTree;
        Environment::GetSingleton()->GetBoolValue("Preprocessor.exportKdTree", exportKdTree);
        if (exportKdTree)
        {
                const long startTime = GetTime();
                cout << "exporting kd tree ... ";

                if (!preprocessor->ExportKdTree(internKdTree))
                {
                        cout << " error exporting kd tree with filename " << internKdTree << endl;
                }
                else
                {
                        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
                }
        }

        // parse view cells related options
        preprocessor->PrepareViewCells();

        if (0) 
        {
                preprocessor->Export(filename + "-out.x3d", true, false, false);
                preprocessor->Export(filename + "-kdtree.x3d", false, true, false);     
        }

        // create a preprocessor thread (note: capsulates calls to boost fuctions!)
        //PreprocessorThread *pt = PreprocessorThreadFactory::Create(preprocessor);
#if USE_THREADS
        PreprocessorThread *pt;

#if USE_QT
        pt = new QtPreprocessorThread(preprocessor);
#else
        pt = new BoostPreprocessorThread(preprocessor);
#endif
#endif

        bool guiSupported = false;
        if (preprocessor->mUseGlRenderer || preprocessor->mUseGlDebugger)
          {
                cout << "using gl widget" << endl;
                // create and run the preprocessor application in a parallel thread
#if USE_THREADS
                pt->InitThread();
                pt->RunThread();
#endif
                
#if USE_QT              
                // display the render widget
                if (!rendererWidget) 
                {
                  // create a qt application first (must be created before any opengl widget ...)
                  QApplication *app = new QApplication(argc, NULL);
                  
                  if (!QGLFormat::hasOpenGL() || !QGLPixelBuffer::hasOpenGLPbuffers()) {
                        QMessageBox::information(0, "OpenGL pbuffers", 
                                                                         "This system does not support OpenGL/pbuffers.",
                                                                         QMessageBox::Ok);
                        return NULL;
                  }
                  
                  
                  rendererWidget = new QtGlRendererWidget(preprocessor->mSceneGraph,
                                                                                                  preprocessor->mViewCellsManager,
                                                                                                  preprocessor->mKdTree);

                  rendererWidget->Show();
                  guiSupported = true; 
                }

                qApp->exec();   
#endif
          }
        
        if (!guiSupported) {
          preprocessor->mUseGlRenderer = false;
          preprocessor->mUseGlDebugger = false;
        }
        
        if (!(preprocessor->mUseGlRenderer || preprocessor->mUseGlDebugger)) {
          // just call the mail method -> will be executed in the main thread
#if USE_THREADS
          pt->RunThread();
#endif
        }
        
        // release memory
        Cleanup();
        
        return returnCode;
}