Changeset 1676 for GTP/trunk/Lib/Vis


Ignore:
Timestamp:
10/24/06 17:42:03 (18 years ago)
Author:
mattausch
Message:

worked on pvs heuristics

Location:
GTP/trunk/Lib/Vis
Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBoundingBoxConverter.h

    r1623 r1676  
    135135                                continue; 
    136136                        } 
    137                          mo-> 
     137                          
    138138                        const AxisAlignedBox bbox = EnlargeBox(mo->getWorldBoundingBox()); 
    139139                                         
    … …  
    225225                         
    226226        // get intersecting scene nodes (= candidates) 
    227         AxisAlignedBox mybox = EnlargeBox(box); 
     227        //AxisAlignedBox mybox = EnlargeBox(box); 
    228228        //mSceneMgr->findNodesIn(mybox, sceneNodeList, NULL); 
    229229        mSceneMgr->findNodesIn(box, sceneNodeList, NULL); 
    … …  
    253253                        const AxisAlignedBox bbox = mo->getWorldBoundingBox(); 
    254254 
    255                         const bool overlaps = Overlap(nodeBox, 
    256                                                                                   OgreTypeConverter::ConvertFromOgre(bbox) 
    257                                                                                   ); 
    258                                                                                   //,0.00001); 
     255                        const bool overlaps =  
     256                                Overlap(nodeBox, OgreTypeConverter::ConvertFromOgre(bbox)); 
     257                                                                                 
    259258         
    260259                         if (overlaps) 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp

    r1640 r1676  
    12011201bool OcclusionCullingSceneManager::LoadViewCells(const String &filename) 
    12021202{ 
    1203         if (mViewCellsLoaded) return true; 
     1203        if (mViewCellsLoaded)  
     1204                return true; 
     1205 
    12041206        // converter between view cell ids and Ogre entites  
    1205         GtpVisibilityPreprocessor::IndexedBoundingBoxContainer iboxes; 
    12061207        OctreeBoundingBoxConverter bconverter(this); 
    12071208 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/Plugin_VisibilitySceneManager.vcproj

    r1320 r1676  
    312312                                Name="VCLinkerTool" 
    313313                                IgnoreImportLibrary="TRUE" 
    314                                 AdditionalDependencies="OgreMain.lib CEGUIBase.lib OgreGUIRenderer.lib Plugin_OctreeSceneManager.lib GtpVisibility.lib zdll.lib zziplib.lib Preprocessor.lib xerces-c_2.lib devil.lib glut32.lib OpenGL32.Lib glu32.lib cg.lib cgGL.lib glew32.lib glew32s.lib" 
     314                                AdditionalDependencies="OgreMain.lib CEGUIBase.lib OgreGUIRenderer.lib Plugin_OctreeSceneManager.lib GtpVisibility.lib zdll.lib zziplib.lib Preprocessor.lib xerces-c_2.lib devil.lib glut32.lib OpenGL32.Lib glu32.lib glew32.lib glew32s.lib" 
    315315                                OutputFile="$(OutDir)/Plugin_VisibilitySceneManager.dll" 
    316316                                Version="0.99" 

  • GTP/trunk/Lib/Vis/Preprocessing/scripts/vsposp_typical.sh

    r1673 r1676  
    6060 
    6161################################################################################## 
    62  
    63  METHOD=gradient-mem 
     62MEMCONST=0.8 
     63 METHOD=gradient-mem-$MEMCONST 
    6464 echo "$SCENE $METHOD" 
    6565 
    … …  
    7171  -hierarchy_subdivision_stats=$LOG_PREFIX-$METHOD-hierarchy-subdivisionStats.log \ 
    7272  -hierarchy_construction_type=2 \ 
    73   -hierarchy_construction_consider_memory2=true \ 
    74  -bvh_construction_render_cost_decrease_weight=0.99 \ 
    75  -vsp_construction_render_cost_decrease_weight=0.99 \ 
    76   -hierarchy_construction_multilevel=false \ 
    77   -hierarchy_term_memory_const=0.9 \ 
    78   -hierarchy_construction_recompute_split_on_repair=true 
    79  
    80 sh movefiles.sh $LOG_PREFIX-$METHOD 
     73  -hierarchy_construction_consider_memory=true \ 
     74 -bvh_construction_render_cost_decrease_weight=0.99 \ 
     75 -vsp_construction_render_cost_decrease_weight=0.99 \ 
     76  -hierarchy_construction_multilevel=false \ 
     77  -hierarchy_term_memory_const=$MEMCONST \ 
     78  -hierarchy_construction_recompute_split_on_repair=true 
     79 
     80sh movefiles.sh $LOG_PREFIX-$METHOD 
     81 
     82 
     83################################################################################## 
     84MEMCONST=0.5 
     85 METHOD=gradient-mem-$MEMCONST 
     86 echo "$SCENE $METHOD" 
     87 
     88  $PROGRAM $ENVIRONMENT \ 
     89  -view_cells_evaluation_stats_prefix=$LOG_PREFIX-$METHOD \ 
     90  -view_cells_merge_stats=$LOG_PREFIX-$METHOD-mergeStats.log \ 
     91  -vsp_subdivision_stats=$LOG_PREFIX-$METHOD-vsp-subdivisionStats.log \ 
     92  -bvh_subdivision_stats=$LOG_PREFIX-$METHOD-bvh-subdivisionStats.log \ 
     93  -hierarchy_subdivision_stats=$LOG_PREFIX-$METHOD-hierarchy-subdivisionStats.log \ 
     94  -hierarchy_construction_type=2 \ 
     95  -hierarchy_construction_consider_memory=true \ 
     96 -bvh_construction_render_cost_decrease_weight=0.99 \ 
     97 -vsp_construction_render_cost_decrease_weight=0.99 \ 
     98  -hierarchy_construction_multilevel=false \ 
     99  -hierarchy_term_memory_const=$MEMCONST \ 
     100  -hierarchy_construction_recompute_split_on_repair=true 
     101 
     102sh movefiles.sh $LOG_PREFIX-$METHOD 
     103 
     104################################################################################## 
     105MEMCONST=0.2 
     106 METHOD=gradient-mem-$MEMCONST 
     107 echo "$SCENE $METHOD" 
     108 
     109  $PROGRAM $ENVIRONMENT \ 
     110  -view_cells_evaluation_stats_prefix=$LOG_PREFIX-$METHOD \ 
     111  -view_cells_merge_stats=$LOG_PREFIX-$METHOD-mergeStats.log \ 
     112  -vsp_subdivision_stats=$LOG_PREFIX-$METHOD-vsp-subdivisionStats.log \ 
     113  -bvh_subdivision_stats=$LOG_PREFIX-$METHOD-bvh-subdivisionStats.log \ 
     114  -hierarchy_subdivision_stats=$LOG_PREFIX-$METHOD-hierarchy-subdivisionStats.log \ 
     115  -hierarchy_construction_type=2 \ 
     116  -hierarchy_construction_consider_memory=true \ 
     117 -bvh_construction_render_cost_decrease_weight=0.99 \ 
     118 -vsp_construction_render_cost_decrease_weight=0.99 \ 
     119  -hierarchy_construction_multilevel=false \ 
     120  -hierarchy_term_memory_const=$MEMCONST \ 
     121  -hierarchy_construction_recompute_split_on_repair=true 
     122 
     123sh movefiles.sh $LOG_PREFIX-$METHOD 
     124 
    81125 
    82126 

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

    r1545 r1676  
    2121{ 
    2222public: 
    23         //BoundingBoxConverter(); 
    2423        /** Takes a vector of indexed bounding boxes and uses it to identify objects with a similar bounding box 
    25                 and to assign the index. 
     24                and assigns them their index (id). 
    2625                The objects are returned in the object container. 
    2726                 

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

    r1673 r1676  
    251251        Environment::GetSingleton()->GetBoolValue("BvHierarchy.useCostHeuristics", mUseCostHeuristics); 
    252252        Environment::GetSingleton()->GetBoolValue("BvHierarchy.useSah", mUseSah); 
    253          
    254         char subdivisionStatsLog[100]; 
     253 
     254    char subdivisionStatsLog[100]; 
    255255        Environment::GetSingleton()->GetStringValue("BvHierarchy.subdivisionStats", subdivisionStatsLog); 
    256256        mSubdivisionStats.open(subdivisionStatsLog); 
    … …  
    260260         
    261261        Environment::GetSingleton()->GetBoolValue("BvHierarchy.Construction.useGlobalSorting", mUseGlobalSorting); 
     262        Environment::GetSingleton()->GetIntValue("BvHierarchy.minRaysForVisibility", mMinRaysForVisibility); 
     263         
    262264 
    263265        mUseBboxAreaForSah = true; 
    … …  
    283285        Debug << "render cost decrease weight: " << mRenderCostDecreaseWeight << endl; 
    284286        Debug << "use global sort: " << mUseGlobalSorting << endl; 
     287        Debug << "minimal rays for visibility: " << mMinRaysForVisibility << endl; 
     288 
    285289        Debug << endl; 
    286290} 
    … …  
    487491        if (computeSplitPlane) 
    488492        { 
     493                const bool sufficientSamples = splitCandidate.mParentData.mNumRays < mMinRaysForVisibility; 
     494 
     495                const bool useVisibiliyBasedHeuristics =  
     496                        !mUseSah && 
     497                        !(mHierarchyManager->GetViewSpaceSubdivisionType() == HierarchyManager::KD_BASED_VIEWSPACE_SUBDIV) && 
     498                        sufficientSamples; 
     499 
    489500                // compute best object partition 
    490501                const float ratio =     SelectObjectPartition(splitCandidate.mParentData,  
    491502                                                                                                  splitCandidate.mFrontObjects,  
    492                                                                                                   splitCandidate.mBackObjects); 
     503                                                                                                  splitCandidate.mBackObjects, 
     504                                                                                                  useVisibiliyBasedHeuristics); 
    493505         
    494506                // cost ratio violated? 
    … …  
    497509                const int previousMisses = splitCandidate.mParentData.mMaxCostMisses; 
    498510 
    499                 splitCandidate.SetMaxCostMisses(maxCostRatioViolated ?  
    500                                                                                 previousMisses + 1 : previousMisses); 
     511                splitCandidate.SetMaxCostMisses(maxCostRatioViolated ? previousMisses + 1 : previousMisses); 
    501512 
    502513        } 
    … …  
    12181229float BvHierarchy::SelectObjectPartition(const BvhTraversalData &tData, 
    12191230                                                                                 ObjectContainer &frontObjects, 
    1220                                                                                  ObjectContainer &backObjects) 
     1231                                                                                 ObjectContainer &backObjects, 
     1232                                                                                 bool useVisibilityBasedHeuristics) 
    12211233{ 
    12221234        ObjectContainer nFrontObjects[3]; 
    … …  
    12451257                //-- split objects using heuristics 
    12461258                                 
    1247                                 if (!mUseSah && 
    1248                                         (mHierarchyManager->GetViewSpaceSubdivisionType() ==  
    1249                                         HierarchyManager::KD_BASED_VIEWSPACE_SUBDIV)) 
     1259                                if (useVisibilityBasedHeuristics) 
    12501260                                { 
    12511261                                        /////////// 

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

    r1673 r1676  
    444444                        if (hm->ConsiderMemory()) 
    445445                        { 
    446                                 const float rc = hm->GetHierarchyStats().mTotalCost - mRenderCostDecrease; 
    447                                 const float mc = hm->GetHierarchyStats().mMemory + 
    448                                                                  (float)mPvsEntriesIncr * ObjectPvs::GetEntrySizeByte(); 
    449                                  
    450                                 return - (rc * mc) / float(1024 * 1024); 
     446                                const float rc = mRenderCostDecrease / hm->GetHierarchyStats().mTotalCost; 
     447                                //const float mc = mMemoryIncr /  / hm->GetHierarchyStats().mMemory; 
     448                                const float mc = (float)mPvsEntriesIncr / (float)hm->GetHierarchyStats().mPvsEntries;    
     449                                //cout << "x"; 
     450                                return hm->GetMemoryConst() * rc + (1.0f - hm->GetMemoryConst()) * mc; 
    451451                        } 
    452452                        else 
    … …  
    672672        float SelectObjectPartition(const BvhTraversalData &tData, 
    673673                                                                ObjectContainer &frontObjects, 
    674                                                                 ObjectContainer &backObjects); 
     674                                                                ObjectContainer &backObjects, 
     675                                                                bool useVisibilityBasedHeuristics); 
    675676         
    676677        /** Writes the node to disk 
    … …  
    733734        float PrepareHeuristics(const BvhTraversalData &tData, const int axis); 
    734735         
    735         /** Reevaluates the priority of this split candidate 
    736                 @returns priority 
    737         */ 
    738         //float EvalPriority(const BvhSubdivisionCandidate &splitCandidate) const; 
    739736 
    740737        //////////////////////////////////////////////// 
    … …  
    924921 
    925922        SortableEntryContainer *mSortedObjects[3]; 
     923 
     924        int mMinRaysForVisibility; 
    926925}; 
    927926 

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

    r1673 r1676  
    24662466                                        "true"); 
    24672467 
    2468          
     2468        RegisterOption("BvHierarchy.minRaysForVisibility", 
     2469                                        optInt, 
     2470                                        "bvh_min_rays_for_vis=", 
     2471                                        "0"); 
     2472 
    24692473 
    24702474        /*******************************************************************/ 

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

    r1673 r1676  
    256256         
    257257        // calculate cost in MB 
    258         const float memoryCost = mHierarchyStats.mMemory  / (1024.0f * 1024.0f) 
     258        const float memoryCost = mHierarchyStats.mMemory  / float(1024 * 1024) 
    259259                                                         + objectSpaceMem + viewSpaceMem; 
    260260 
    … …  
    383383        // number of initial splits 
    384384        const int minSteps = mMinStepsOfSameType; 
     385        const int maxSteps = mMinStepsOfSameType + 500; 
    385386        float renderCostDecr = Limits::Infinity; 
    386387 
    387         SubdivisionCandidate *osc =  
    388                 PrepareObjectSpaceSubdivision(sampleRays, objects); 
     388        SubdivisionCandidate *osc = PrepareObjectSpaceSubdivision(sampleRays, objects); 
    389389         
    390390        objectSpaceQueue.Push(osc); 
    … …  
    399399        // for first round, use sah splits. Once view space partition 
    400400        // has started, use render cost heuristics instead 
    401         const int ospSteps = RunConstruction(objectSpaceQueue, dirtyVspList, NULL, minSteps); 
     401        const int ospSteps =  
     402                RunConstruction(objectSpaceQueue, dirtyVspList, NULL, minSteps, maxSteps); 
    402403 
    403404        cout << "\n" << ospSteps << " object space partition steps taken" << endl; 
    … …  
    440441                        // for first round, use sah splits. Once view space partition 
    441442                        // has started, use render cost heuristics instead 
    442                         const int ospSteps =  
    443                                 RunConstruction(objectSpaceQueue, dirtyVspList, viewSpaceQueue.Top(), minSteps); 
     443                        const int ospSteps = RunConstruction(objectSpaceQueue,  
     444                                                                                                 dirtyVspList,  
     445                                                                                                 viewSpaceQueue.Top(),  
     446                                                                                                 minSteps,  
     447                                                                                                 maxSteps); 
    444448 
    445449                        cout << "\n" << ospSteps << " object space partition steps taken" << endl; 
    … …  
    461465                        // process view space candidates 
    462466                        const int vspSteps =  
    463                                 RunConstruction(viewSpaceQueue, dirtyOspList, objectSpaceQueue.Top(), minSteps); 
     467                                RunConstruction(viewSpaceQueue, dirtyOspList, objectSpaceQueue.Top(), minSteps, maxSteps); 
    464468 
    465469                        cout << "\n" << vspSteps << " view space partition steps taken" << endl; 
    … …  
    700704 
    701705        // memory size in byte 
    702         mHierarchyStats.mMemory += (float)ObjectPvs::GetEntrySizeByte(); 
     706        mHierarchyStats.mMemory += (float)ObjectPvs::GetEntrySizeByte() * pvsEntriesIncr; 
    703707        mHierarchyStats.mRenderCostDecrease = sc->GetRenderCostDecrease(); 
    704708 
    … …  
    841845 
    842846                        cout << "\nstarting object space subdivision after "  
    843                                  << mVspTree->mVspStats.nodes << " ("  
    844                                  << mMinStepsOfSameType << ") " << endl; 
     847                                 << mVspTree->mVspStats.nodes << " (" << mMinStepsOfSameType << ") " << endl; 
    845848 
    846849                        SubdivisionCandidate *ospSc = PrepareObjectSpaceSubdivision(sampleRays, objects); 
    … …  
    895898                                                                          SubdivisionCandidateContainer &dirtyCandidates, 
    896899                                                                          SubdivisionCandidate *oldCandidate, 
    897                                                                           const int minSteps) 
    898 { 
     900                                                                          const int minSteps, 
     901                                                                          const int maxSteps) 
     902{ 
     903        if (minSteps >= maxSteps) 
     904                cout << "error!! " << minSteps << " equal or larger maxSteps" << endl; 
     905 
    899906        int steps = 0; 
    900907        SubdivisionCandidate::NewMail(); 
    … …  
    908915 
    909916                // minimum slope reached 
    910                 if ((sc->GetPriority() < threshold) && !(steps < minSteps)) 
    911                 { 
    912                         cout << "**************** breaking on " << sc->GetPriority() << " smaller than " << threshold << endl; 
     917                if ((steps > maxSteps) ||  
     918                        ((sc->GetPriority() < threshold) && !(steps < minSteps))) 
     919                { 
     920                        cout << "\n**************** breaking on " << sc->GetPriority() << " smaller than " << threshold << endl; 
    913921                        break; 
    914922                } 

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

    r1673 r1676  
    233233 
    234234        inline bool ConsiderMemory() const { return mConsiderMemory; } 
     235        inline float GetMemoryConst() const { return mMemoryConst; } 
     236 
    235237 
    236238protected: 
    … …  
    273275                                                //const float minRenderCostDecr, 
    274276                                                SubdivisionCandidate *oldCandidate, 
    275                                                 const int minSteps); 
     277                                                const int minSteps, 
     278                                                const int maxSteps); 
    276279 
    277280        /** Default subdivision method. 

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

    r1667 r1676  
    602602ViewCellsManager *ViewCellsManager::LoadViewCells(const string &filename,  
    603603                                                                                                  ObjectContainer *objects, 
    604                                                                                                   const bool finalizeViewCells, 
     604                                                                                                  bool finalizeViewCells, 
    605605                                                                                                  BoundingBoxConverter *bconverter) 
    606606                                                                                                  

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

    r1666 r1676  
    447447        static ViewCellsManager *LoadViewCells(const string &filename,  
    448448                                                                                   ObjectContainer *objects,  
    449                                                                                    const bool finalizeViewCells, 
     449                                                                                   bool finalizeViewCells = false, 
    450450                                                                                   BoundingBoxConverter *bconverter = NULL); 
    451451 

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

    r1673 r1676  
    491491                        if (hm->ConsiderMemory()) 
    492492                        { 
    493                                 const float rc = hm->GetHierarchyStats().mTotalCost - mRenderCostDecrease; 
    494                                 const float mc = hm->GetHierarchyStats().mMemory + 
    495                                                                  (float)mPvsEntriesIncr * ObjectPvs::GetEntrySizeByte(); 
    496  
    497                                 return - (rc * mc) / float(1024 * 1024); 
     493                                const float rc = mRenderCostDecrease / hm->GetHierarchyStats().mTotalCost; 
     494                                const float mc = (float)mPvsEntriesIncr / (float)hm->GetHierarchyStats().mPvsEntries; 
     495                                //cout << "y";                   
     496                                return hm->GetMemoryConst() * rc + (1.0f - hm->GetMemoryConst()) * mc; 
    498497                        } 
    499498                        else 
Note: See TracChangeset for help on using the changeset viewer.