Ignore:
Timestamp:
11/07/06 21:32:10 (18 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/Lib/Vis/Preprocessing/src
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/Preprocessing/src/BvHierarchy.cpp

    r1718 r1723  
    844844        float minBorder = nodeBbox.Max(axis); 
    845845        float maxBorder = nodeBbox.Min(axis); 
     846 
    846847        float areaLeft = 0, areaRight = 0; 
    847848 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Environment.cpp

    r1713 r1723  
    12421242          "vss_store_storedInitialSamples=", 
    12431243          "false"); 
    1244     
    1245    RegisterOption("VssPreprocessor.useViewSpaceBox", 
    1246           optBool, 
    1247           "vss_use_viewspace_box=", 
    1248           "false");    
    1249     
     1244   
    12501245 
    12511246 
    … …  
    18201815                                        "false"); 
    18211816 
    1822  
     1817   RegisterOption("Preprocessor.useViewSpaceBox", 
     1818          optBool, 
     1819          "preprocessor_use_viewspace_box=", 
     1820          "false");    
     1821    
    18231822        /*************************************************************************/ 
    18241823        /*             VSS Preprocessor cells related options                    */ 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Exporter.cpp

    r1707 r1723  
    234234        ObjectContainer::const_iterator oit, oit_end = objects.end(); 
    235235 
    236         if (0&&!exportSingleMesh) 
     236        if (!exportSingleMesh) 
    237237        { 
    238238                for (oit = objects.begin(); oit != oit_end; ++ oit) 

  • GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.cpp

    r1719 r1723  
    7979 
    8080 
     81void HierarchySubdivisionStats::Print(ostream &app) const 
     82{ 
     83        app << "#Pass\n" << 0 << endl 
     84                << "#Splits\n" << mNumSplits << endl  
     85                << "#TotalRenderCost\n" << mTotalRenderCost << endl 
     86                << "#TotalEntriesInPvs\n" << mEntriesInPvs << endl 
     87                << "#Memory\n" << mMemoryCost << endl 
     88                << "#StepsView\n" << mViewSpaceSplits << endl 
     89                << "#StepsObject\n" << mObjectSpaceSplits << endl 
     90                << "#VspOspRatio\n" << VspOspRatio() << endl 
     91                << "#FullMem\n" << mFullMemory << endl 
     92                << "#RenderCostDecrease\n" << mRenderCostDecrease << endl 
     93                << "#FpsPerMb\n" << FpsPerMb() << endl 
     94                << endl; 
     95} 
     96 
     97 
    8198void HierarchyManager::ParseEnvironment() 
    8299{ 
    … …  
    265282{ 
    266283        // question: should I also add the mem usage of the hierarchies? 
    267         const float objectSpaceMem = 0;//GetObjectSpaceMemUsage(); 
    268         const float viewSpaceMem = 0;//mVspTree->GetMemUsage(); 
    269          
    270         // calculate cost in MB 
    271         const float memoryCost = mHierarchyStats.mMemory  / float(1024 * 1024) 
    272                                                          + objectSpaceMem + viewSpaceMem; 
    273  
    274         //cout << "pvs entries " << mHierarchyStats.pvsEntries << endl; 
    275         AddSubdivisionStats(mHierarchyStats.Leaves(), 
    276                                                 mHierarchyStats.mRenderCostDecrease, 
    277                                                 mHierarchyStats.mTotalCost, 
    278                                                 mHierarchyStats.mPvsEntries, 
    279                                                 memoryCost, 
    280                                                 1.0f / (mHierarchyStats.mTotalCost * memoryCost), 
    281                                                 (float)mVspTree->mVspStats.Leaves() / (float)GetObjectSpaceSubdivisionLeaves() 
    282                                                 ); 
     284        const float objectSpaceMem = GetObjectSpaceMemUsage(); 
     285        const float viewSpaceMem = mVspTree->GetMemUsage(); 
     286                 
     287        HierarchySubdivisionStats stats; 
     288        stats.mNumSplits = mHierarchyStats.Leaves(); 
     289        stats.mTotalRenderCost = mHierarchyStats.mTotalCost; 
     290        stats.mEntriesInPvs = mHierarchyStats.mPvsEntries; 
     291        stats.mMemoryCost = mHierarchyStats.mMemory  / float(1024 * 1024); 
     292        stats.mFullMemory = mHierarchyStats.mMemory  / float(1024 * 1024) 
     293                                                + objectSpaceMem + viewSpaceMem; 
     294        stats.mViewSpaceSplits = mVspTree->mVspStats.Leaves(); 
     295        stats.mObjectSpaceSplits = GetObjectSpaceSubdivisionLeaves(); 
     296         
     297        stats.Print(mSubdivisionStats); 
    283298} 
    284299 
    … …  
    299314                        << "#Memory\n" << memory << endl 
    300315                        << "#FpsPerMb\n" << renderCostPerStorage << endl 
    301                         << "#VspOspRatio\n" << vspOspRatio << endl; 
     316                        << "#VspOspRatio\n" << vspOspRatio << endl 
     317                        << endl; 
    302318} 
    303319 
    … …  
    882898 
    883899                        cout << "\nstarting object space subdivision after "  
    884                                  << mVspTree->mVspStats.nodes << " (" << mMinStepsOfSameType << ") " << endl; 
     900                                 << mVspTree->mVspStats.nodes << " (" << mMinStepsOfSameType << ") steps, mem="  
     901                                 << mHierarchyStats.mMemory / float(1024 * 1024) << " MB" << endl; 
    885902 
    886903                        SubdivisionCandidate *ospSc = PrepareObjectSpaceSubdivision(sampleRays, objects); 
    … …  
    897914                        mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType; 
    898915 
    899                         cout << "\nstarting view space subdivision at depth "  
     916                        cout << "\nstarting view space subdivision at "  
    900917                                 << GetObjectSpaceSubdivisionLeaves() << " ("  
    901                                  << mMinStepsOfSameType << ") " << endl; 
     918                                 << mMinStepsOfSameType << ") , mem="  
     919                                 << mHierarchyStats.mMemory / float(1024 * 1024) << " MB" << endl; 
    902920 
    903921                        SubdivisionCandidate *vspSc = PrepareViewSpaceSubdivision(sampleRays, objects); 
    … …  
    16021620 
    16031621 
    1604 static void UpdateStats(ofstream &stats, 
    1605                                                 const int splits, 
    1606                                                 const float totalRenderCost, 
    1607                                                 const int entriesInPvs, 
    1608                                                 const float memoryCost, 
    1609                                                 const int viewSpaceSplits, 
    1610                                                 const int objectSpaceSplits) 
    1611 { 
    1612         stats << "#Pass\n" << 0 << endl 
    1613                    << "#Splits\n" << splits << endl  
    1614                    << "#TotalRenderCost\n" << totalRenderCost << endl 
    1615                    << "#TotalEntriesInPvs\n" << entriesInPvs << endl 
    1616                    << "#Memory\n" << memoryCost << endl 
    1617                    << "#ViewSpaceSplits\n" << viewSpaceSplits << endl 
    1618                    << "#ObjectSpaceSplits\n" << objectSpaceSplits << endl 
    1619                    << "#VspOspRatio\n" << (float)viewSpaceSplits / (float)objectSpaceSplits << endl 
    1620                    << endl; 
    1621 } 
    1622  
    1623  
    16241622class HierarchyNodeWrapper; 
    16251623 
    … …  
    18631861                                                                   const ObjectContainer &objects) 
    18641862{ 
    1865         float totalRenderCost = (float)objects.size(); 
    1866         int entriesInPvs = 1; 
    1867         int steps = 0; 
    1868         int viewSpaceSplits = 0; 
    1869         int objectSpaceSplits = 0; 
     1863        HierarchySubdivisionStats subStats; 
     1864        subStats.Reset(); 
     1865 
     1866        ///////////// 
     1867        //-- initial situation 
     1868 
     1869        subStats.mNumSplits = 0; 
     1870        subStats.mTotalRenderCost = (float)objects.size(); 
     1871        subStats.mEntriesInPvs = 1; 
     1872        subStats.mMemoryCost = (float)ObjectPvs::GetEntrySize(); 
     1873        subStats.mFullMemory = subStats.mMemoryCost; 
     1874        subStats.mViewSpaceSplits = 0; 
     1875        subStats.mObjectSpaceSplits = 0; 
     1876         
     1877        subStats.Print(stats); 
    18701878 
    18711879        cout << "exporting vsposp stats ... " << endl; 
    1872         const float memoryCost = (float)entriesInPvs * (float)ObjectPvs::GetEntrySize(); 
    1873  
    1874         ///////////// 
    1875         //-- first view cell 
    1876  
    1877         UpdateStats(stats, 2, totalRenderCost, entriesInPvs, memoryCost, viewSpaceSplits, objectSpaceSplits); 
    18781880 
    18791881        //-- go through tree in the order of render cost decrease 
    … …  
    18981900                         
    18991901                        isLeaf = newNode->IsLeaf(); 
    1900                         rcDecr = oldNode->mRenderCostDecr; 
     1902                        subStats.mRenderCostDecrease = oldNode->mRenderCostDecr; 
    19011903                        entriesIncr = oldNode->mPvsEntriesIncr; 
    19021904                } 
    … …  
    19091911                         
    19101912                        isLeaf = newNode->IsLeaf(); 
    1911                         rcDecr = oldNode->mRenderCostDecr; 
     1913                        subStats.mRenderCostDecrease = oldNode->mRenderCostDecr; 
    19121914                        entriesIncr = oldNode->mPvsEntriesIncr; 
    19131915                }                
    … …  
    19151917                if (!isLeaf) 
    19161918                { 
    1917                         totalRenderCost -= rcDecr; 
    1918                         entriesInPvs += entriesIncr; 
     1919                        subStats.mTotalRenderCost -= subStats.mRenderCostDecrease; 
     1920                        subStats.mEntriesInPvs += entriesIncr; 
     1921 
    19191922                        // if (rcDecr <= 0) 
    19201923                        if (nextCandidate->Type() == SubdivisionCandidate::VIEW_SPACE) 
    19211924                        { 
    1922                                 ++ viewSpaceSplits; 
     1925                                ++ subStats.mViewSpaceSplits; 
    19231926                                cout << "v";//cout << "vsp t: " << timeStamp << " rc: " << rcDecr << " pvs: " << entriesIncr << endl; 
    19241927                        } 
    19251928                        else 
    19261929                        { 
    1927                                 ++ objectSpaceSplits; 
     1930                                ++ subStats.mObjectSpaceSplits; 
    19281931                                cout << "o";//"osp t: " << timeStamp << " rc: " << rcDecr << " pvs: " << entriesIncr << endl; 
    19291932                        } 
    19301933 
    1931                         ++ steps; 
    1932  
    1933                         if ((steps % 500) == 499) 
    1934                                 cout << steps << " steps taken" << endl; 
    1935  
    1936                         const float memoryCost = (float)entriesInPvs * (float)ObjectPvs::GetEntrySize(); 
    1937                         UpdateStats(stats, steps, totalRenderCost, entriesInPvs, memoryCost, viewSpaceSplits, objectSpaceSplits); 
     1934                        ++ subStats.mNumSplits; 
     1935 
     1936                        if ((subStats.mNumSplits % 500) == 499) 
     1937                                cout << subStats.mNumSplits << " steps taken" << endl; 
     1938 
     1939                        subStats.mMemoryCost = (float)subStats.mEntriesInPvs * (float)ObjectPvs::GetEntrySize(); 
     1940                        subStats.mFullMemory = subStats.mMemoryCost; 
     1941 
     1942                        subStats.Print(stats); 
     1943                         
    19381944                } 
    19391945 
    … …  
    20232029                                                                                        const int splitsStepSize) 
    20242030{ 
     2031        HierarchySubdivisionStats subStats; 
     2032         
    20252033        int splits = 0; 
    20262034 
    2027         float renderCost; 
    2028         float memory; 
    2029         int pvsEntries; 
    2030         int viewSpaceSplits; 
    2031         int objectSpaceSplits; 
    2032  
    20332035        while (1) 
    20342036        { 
    2035                 const int numSplits = ExtractStatistics(splits,  
     2037                subStats.mNumSplits = ExtractStatistics(splits,  
    20362038                                                                                                99999.0,  
    2037                                                                                                 renderCost,  
    2038                                                                                                 memory,  
    2039                                                                                                 pvsEntries, 
    2040                                                                                                 viewSpaceSplits, 
    2041                                                                                                 objectSpaceSplits); 
     2039                                                                                                subStats.mTotalRenderCost,  
     2040                                                                                                subStats.mMemoryCost,  
     2041                                                                                                subStats.mEntriesInPvs, 
     2042                                                                                                subStats.mViewSpaceSplits, 
     2043                                                                                                subStats.mObjectSpaceSplits); 
     2044 
    20422045                 
    2043                 UpdateStats(splitsStats,  
    2044                                         numSplits,  
    2045                                         renderCost,  
    2046                                         pvsEntries,  
    2047                                         memory,  
    2048                                         viewSpaceSplits,  
    2049                                         objectSpaceSplits); 
     2046                const float objectSpaceHierarchyMem = float( 
     2047                                                                                          subStats.mObjectSpaceSplits * sizeof(BvhLeaf *) +  
     2048                                                                                          (subStats.mObjectSpaceSplits - 1) * sizeof(BvhInterior *) +  
     2049                                                                                          sizeof(BvHierarchy) 
     2050                                                                                          ) / float(1024 * 1024); 
     2051 
     2052                         
     2053                const float viewSpaceHierarchyMem = float( 
     2054                                                                                        subStats.mViewSpaceSplits * sizeof(VspLeaf *) +  
     2055                                                                                        (subStats.mViewSpaceSplits - 1) * sizeof(VspInterior *) +  
     2056                                                                                        sizeof(VspTree) 
     2057                                                                                        )  / float(1024 * 1024); 
     2058 
     2059                subStats.mFullMemory = subStats.mMemoryCost + objectSpaceHierarchyMem + viewSpaceHierarchyMem; 
     2060                 
     2061                subStats.Print(splitsStats); 
    20502062 
    20512063                splits += splitsStepSize; 
    20522064 
    2053                 if (numSplits == mHierarchyStats.Leaves()) 
     2065                if (subStats.mNumSplits == mHierarchyStats.Leaves()) 
    20542066                        break; 
    20552067        } 

  • GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.h

    r1718 r1723  
    108108 
    109109 
     110class HierarchySubdivisionStats 
     111{ 
     112public: 
     113             
     114        int mNumSplits; 
     115                 
     116        float mRenderCostDecrease; 
     117 
     118    float mTotalRenderCost; 
     119     
     120        int mEntriesInPvs; 
     121     
     122        float mMemoryCost; 
     123         
     124        float mFullMemory; 
     125 
     126        int mViewSpaceSplits; 
     127 
     128        int mObjectSpaceSplits; 
     129 
     130 
     131        float VspOspRatio() const { return (float)mViewSpaceSplits / (float)mObjectSpaceSplits; } 
     132 
     133        float FpsPerMb() const { return 1.0f / (mTotalRenderCost * mMemoryCost); } 
     134 
     135        HierarchySubdivisionStats() { Reset(); } 
     136 
     137        void Reset() 
     138        { 
     139                mNumSplits = 0; 
     140                mRenderCostDecrease = 0; 
     141                mTotalRenderCost = 0; 
     142                mEntriesInPvs = 0; 
     143                mMemoryCost = 0; 
     144                mFullMemory = 0; 
     145                mViewSpaceSplits = 0; 
     146                mObjectSpaceSplits = 0; 
     147        } 
     148 
     149 
     150        void Print(ostream &app) const; 
     151 
     152        friend ostream &operator<<(ostream &s, const HierarchySubdivisionStats &stat) 
     153        { 
     154                stat.Print(s); 
     155                return s; 
     156        } 
     157}; 
     158 
     159 
    110160/** This class implements a structure holding two different hierarchies, 
    111161        one for object space partitioning and one for view space partitioning. 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.cpp

    r1715 r1723  
    161161        Environment::GetSingleton()->GetBoolValue("Preprocessor.exportObj", mExportObj); 
    162162         
     163        Environment::GetSingleton()->GetBoolValue("Preprocessor.useViewSpaceBox", mUseViewSpaceBox); 
     164 
    163165        Debug << "******* Preprocessor Options **********" << endl; 
    164166        Debug << "detect empty view space=" << mDetectEmptyViewSpace << endl; 
    … …  
    166168        Debug << "load meshes: " << mLoadMeshes << endl; 
    167169        Debug << "export obj: " << mExportObj << endl; 
     170        Debug << "use view space box: " << mUseViewSpaceBox << endl; 
    168171} 
    169172 
    … …  
    515518                // temp hack 
    516519                //ExportObj("cropped_vienna.obj", mObjects); 
    517  
    518520                mSceneGraph->GetRoot()->UpdateBox(); 
    519521                                 
    520522                cout << "finished loading" << endl; 
    521  
    522                  
    523                 if (0) 
    524                 { 
    525                         Exporter *exporter = Exporter::GetExporter("testload.x3d"); 
    526                         if (exporter) 
    527                         { 
    528                                 exporter->ExportGeometry(mObjects); 
    529                                 delete exporter; 
    530                         } 
    531                 } 
    532523        } 
    533524 
    … …  
    658649 
    659650                // default view space is the extent of the scene 
    660                 AxisAlignedBox3 box = mSceneGraph->GetBox(); 
    661                                          
    662                 if (0) 
    663                 { 
     651                AxisAlignedBox3 viewSpaceBox; 
     652                         
     653                if (mUseViewSpaceBox) 
     654                { 
     655                        viewSpaceBox = mSceneGraph->GetBox(); 
     656 
    664657                        // use a small box outside of the scene 
    665                         box.Scale(Vector3(0.1f,0.5f,0.5f)); 
    666                         box.Translate(Vector3(Magnitude(mSceneGraph->GetBox().Size())*0.5f, 0, 0)); 
    667                 } 
    668  
    669                 mViewCellsManager->SetViewSpaceBox(box); 
    670           
     658                        viewSpaceBox.Scale(Vector3(0.15f, 0.3f, 0.5f)); 
     659                        //viewSpaceBox.Translate(Vector3(Magnitude(mSceneGraph->GetBox().Size()) * 0.5f, 0, 0)); 
     660                        viewSpaceBox.Translate(Vector3(Magnitude(mSceneGraph->GetBox().Size()) * 0.3f, 0, 0)); 
     661                        mViewCellsManager->SetViewSpaceBox(viewSpaceBox); 
     662                } 
     663                else 
     664                { 
     665                        viewSpaceBox = mSceneGraph->GetBox(); 
     666                        mViewCellsManager->SetViewSpaceBox(viewSpaceBox); 
     667                } 
     668 
    671669                bool loadVcGeometry; 
    672670                Environment::GetSingleton()->GetBoolValue("ViewCells.loadGeometry", loadVcGeometry); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.h

    r1695 r1723  
    196196 
    197197        int mPass; 
    198    
    199   bool mDelayVisibilityComputation; 
    200   bool mStopComputation; 
     198  
     199    bool mDelayVisibilityComputation; 
     200        bool mStopComputation; 
    201201   
    202202        bool mExportObj; 
    203  
    204203 
    205204protected: 
    … …  
    231230        GlRendererBuffer *renderer; 
    232231 
    233  
     232        /// if box around view space should be used 
     233        bool mUseViewSpaceBox; 
    234234}; 
    235235 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Pvs.h

    r1715 r1723  
    422422                                                  const float pdf) 
    423423{ 
    424   mSamples--; 
     424  -- mSamples; 
    425425   
    426426  std::map<T, S, LtSample<T> >:: 

  • GTP/trunk/Lib/Vis/Preprocessing/src/RssPreprocessor.cpp

    r1715 r1723  
    496496 
    497497        long time = GetTime(); 
    498         totalTime = TimeDiff(startTime, time)*1e-3; 
     498        totalTime = TimeDiff(startTime, time)*1e-3f; 
    499499        lastTime = time; 
    500500         

  • GTP/trunk/Lib/Vis/Preprocessing/src/TestPreprocessor.vcproj

    r1718 r1723  
    206206                                Name="VCLinkerTool" 
    207207                                AdditionalDependencies="xerces-c_2.lib glew32.lib zdll.lib zziplib.lib devil.lib glut32.lib OpenGL32.Lib glu32.lib Preprocessor.lib RTScene.lib RTWorld.lib QtCore4.lib qtmain.lib QtOpenGL4.lib Qt3Support4.lib QtTest4.lib QtGui4.lib QtGlRenderer.lib" 
    208                                 OutputFile="../bin/release/Preprocessor2.exe" 
     208                                OutputFile="../bin/release/Preprocessor.exe" 
    209209                                LinkIncremental="1" 
    210210                                AdditionalLibraryDirectories="..\src\GL;..\lib\release;..\..\Preprocessing\lib\release;..\..\..\..\..\..\NonGTP\Boost\lib;..\..\..\..\..\..\NonGTP\Xerces\xercesc\lib;..\..\..\..\..\..\NonGTP\Zlib\lib;..\..\..\..\..\..\NonGTP\Devil\lib;..\MultiLevelRayTracing\RTScene\Release;..\MultiLevelRayTracing\RTWorld\Release;&quot;$(QTDIR)\lib&quot;;.\QtGlRenderer\Release" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

    r1718 r1723  
    4242// HACK 
    4343const static bool SAMPLE_AFTER_SUBDIVISION = true; 
    44 //const static bool CLAMP_TO_BOX = false; 
    45 const static bool CLAMP_TO_BOX = true; 
     44const static bool CLAMP_TO_BOX = false; 
     45//const static bool CLAMP_TO_BOX = true; 
    4646 
    4747 

  • GTP/trunk/Lib/Vis/Preprocessing/src/VssPreprocessor.cpp

    r1705 r1723  
    3636  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.loadInitialSamples", mLoadInitialSamples); 
    3737  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.storeInitialSamples", mStoreInitialSamples); 
    38   Environment::GetSingleton()->GetBoolValue("VssPreprocessor.useViewSpaceBox", mUseViewSpaceBox); 
    3938  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.testBeamSampling", mTestBeamSampling); 
    4039  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.enlargeViewSpace", mEnlargeViewSpace); 
    … …  
    376375        int totalSamples = 0; 
    377376 
    378         if (mUseViewSpaceBox) 
    379         { 
    380                 AxisAlignedBox3 viewSpaceBox; 
    381                 viewSpaceBox.Initialize(); 
    382  
    383                 viewSpaceBox = AxisAlignedBox3(mKdTree->GetBox()); 
    384                 AxisAlignedBox3 tbox(mViewCellsManager->GetViewSpaceBox()); 
    385  
    386                 const Vector3 size = tbox.Size(); 
    387                 viewSpaceBox.SetMax(0, tbox.Max(0) + size[0] * 0.5f); 
    388                 viewSpaceBox.SetMin(0, tbox.Min(0) + size[0]); 
    389                   
    390                 // change the view space of the view cells manager 
    391                 mViewCellsManager->SetViewSpaceBox(viewSpaceBox); 
    392         } 
    393  
    394         mSceneGraph->CollectObjects(&mObjects); 
     377        //mSceneGraph->CollectObjects(&mObjects); 
    395378 
    396379        if (!mLoadViewCells) 

  • GTP/trunk/Lib/Vis/Preprocessing/src/VssPreprocessor.h

    r1563 r1723  
    3636  /// if initial samples should be stored in file 
    3737  bool mStoreInitialSamples; 
    38   /// if box around view space should be used 
    39   bool mUseViewSpaceBox; 
     38  
    4039  // rays cast during the processing 
    4140  VssRayContainer mVssRays; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/main.cpp

    r1715 r1723  
    149149} 
    150150 
    151  
     151#include "ViewCellsManager.h" 
    152152int 
    153153main(int argc, char **argv) 
    … …  
    244244                } 
    245245        } 
     246         
     247         
     248        // parse view cells related options 
     249        if (!preprocessor->PrepareViewCells()) 
     250        { 
     251                Cleanup(); 
     252                exit(1); 
     253        } 
     254 
    246255        if (0){ 
    247256        Exporter *exporter= Exporter::GetExporter("test1.wrl"); 
    248         AxisAlignedBox3 bbox = preprocessor->mKdTree->GetBox();  
    249         bbox.Scale(Vector3(0.5, 1, 0.5)); 
     257        AxisAlignedBox3 bbox = preprocessor->mViewCellsManager->GetViewSpaceBox();  
    250258    exporter->SetWireframe(); 
    251         exporter->ExportBox(preprocessor->mKdTree->GetBox()); 
    252259        exporter->ExportBox(bbox); 
    253260        exporter->SetFilled(); 
    254         exporter->ExportGeometry(preprocessor->mObjects, true, &bbox); 
     261        exporter->ExportGeometry(preprocessor->mObjects, true); 
    255262        delete exporter; 
    256263        } 
    257264         
    258          
    259         // parse view cells related options 
    260         if (!preprocessor->PrepareViewCells()) 
    261         { 
    262                 Cleanup(); 
    263                 exit(1); 
    264         } 
    265  
    266265        if (0)  
    267266        { 
Note: See TracChangeset for help on using the changeset viewer.