Ignore:
Timestamp:
10/23/06 20:24:14 (18 years ago)
Author:
mattausch
Message:

updated priority meaurement: taking total cost and memory into account

File:
1 edited

Legend:

Unmodified
Added
Removed
  • GTP/trunk/Lib/Vis/Preprocessing/src/BvHierarchy.cpp

    r1666 r1667  
    411411                                                                const bool globalCriteriaMet) 
    412412{ 
    413         BvhSubdivisionCandidate *sc =  
    414                 dynamic_cast<BvhSubdivisionCandidate *>(splitCandidate); 
     413        BvhSubdivisionCandidate *sc = dynamic_cast<BvhSubdivisionCandidate *>(splitCandidate); 
    415414        BvhTraversalData &tData = sc->mParentData; 
    416415 
     
    439438                //-- push the new split candidates on the queue 
    440439                 
    441                 BvhSubdivisionCandidate *frontCandidate =  
    442                         new BvhSubdivisionCandidate(tFrontData); 
    443                 BvhSubdivisionCandidate *backCandidate =  
    444                         new BvhSubdivisionCandidate(tBackData); 
     440                BvhSubdivisionCandidate *frontCandidate = new BvhSubdivisionCandidate(tFrontData); 
     441                BvhSubdivisionCandidate *backCandidate = new BvhSubdivisionCandidate(tBackData); 
    445442 
    446443                EvalSubdivisionCandidate(*frontCandidate); 
     
    485482 
    486483 
    487 void BvHierarchy::EvalSubdivisionCandidate(BvhSubdivisionCandidate &splitCandidate) 
    488 { 
    489         // compute best object partition 
    490         const float ratio =     SelectObjectPartition( 
    491                                                         splitCandidate.mParentData,  
    492                                                         splitCandidate.mFrontObjects,  
    493                                                         splitCandidate.mBackObjects); 
    494          
     484void BvHierarchy::EvalSubdivisionCandidate(BvhSubdivisionCandidate &splitCandidate,  
     485                                                                                   bool computeSplitPlane) 
     486{ 
     487        if (computeSplitPlane) 
     488        { 
     489                // compute best object partition 
     490                const float ratio =     SelectObjectPartition(splitCandidate.mParentData,  
     491                                                                                                  splitCandidate.mFrontObjects,  
     492                                                                                                  splitCandidate.mBackObjects); 
     493         
     494                // cost ratio violated? 
     495                const bool maxCostRatioViolated = mTermMaxCostRatio < ratio; 
     496 
     497                const int previousMisses = splitCandidate.mParentData.mMaxCostMisses; 
     498 
     499                splitCandidate.SetMaxCostMisses(maxCostRatioViolated ?  
     500                                                                                previousMisses + 1 : previousMisses); 
     501 
     502        } 
     503 
    495504        BvhLeaf *leaf = splitCandidate.mParentData.mNode; 
    496  
    497         // cost ratio violated? 
    498         const bool maxCostRatioViolated = mTermMaxCostRatio < ratio; 
    499  
    500         const int previousMisses = splitCandidate.mParentData.mMaxCostMisses; 
    501  
    502         splitCandidate.SetMaxCostMisses(maxCostRatioViolated ?  
    503                 previousMisses + 1 : previousMisses); 
    504505 
    505506        const float oldProp = EvalViewCellsVolume(leaf->mObjects); 
     
    507508                 
    508509        // compute global decrease in render cost 
    509         const float newRenderCost =  
    510                 EvalRenderCost(splitCandidate.mFrontObjects) + 
    511                 EvalRenderCost(splitCandidate.mBackObjects); 
     510        const float newRenderCost = EvalRenderCost(splitCandidate.mFrontObjects) + 
     511                                                                EvalRenderCost(splitCandidate.mBackObjects); 
    512512 
    513513        const float renderCostDecr = oldRenderCost - newRenderCost; 
     
    527527        float priority; 
    528528 
     529        // surface area heuristics is used when there is no view space subdivision available.  
     530        // In order to have some prioritized traversal, use this formula instead 
    529531        if (mHierarchyManager->GetViewSpaceSubdivisionType() ==  
    530532                HierarchyManager::NO_VIEWSPACE_SUBDIV) 
     
    541543        else 
    542544        { 
     545                // take render cost of node into account  
     546                // otherwise danger of being stuck in a local minimum! 
    543547                const float factor = mRenderCostDecreaseWeight; 
    544                  
    545548                priority = factor * renderCostDecr + (1.0f - factor) * oldRenderCost; 
    546549 
    547                 // take render cost of node into account  
    548                 // otherwise danger of being stuck in a local minimum!! 
    549                 if (mHierarchyManager->mConsiderMemory) 
    550                 { 
    551                         //cout << "here7 rc: " << factor * renderCostDecr << " pvs: " << (1.0f - factor) * splitCandidate.GetPvsEntriesIncr() << endl; 
    552                         //priority = factor * renderCostDecr - (1.0f - factor) * splitCandidate.GetPvsEntriesIncr();// / mBvhStats.Leaves(); 
     550                if (1)//0 && mHierarchyManager->mConsiderMemory) 
     551                { 
    553552                        priority /= ((float)splitCandidate.GetPvsEntriesIncr() + mHierarchyManager->mMemoryConst); 
    554553                } 
     
    557556        // compute global decrease in render cost 
    558557        splitCandidate.SetPriority(priority); 
    559 } 
    560  
    561  
    562 float BvHierarchy::EvalPriority(const BvhSubdivisionCandidate &splitCandidate) const 
    563 { 
    564         BvhLeaf *leaf = splitCandidate.mParentData.mNode; 
    565  
    566         const float oldRenderCost = EvalRenderCost(leaf->mObjects); 
    567  
    568         // compute global decrease in render cost 
    569         const float newRenderCost = EvalRenderCost(splitCandidate.mFrontObjects) + 
    570                                                                 EvalRenderCost(splitCandidate.mBackObjects); 
    571  
    572         const float renderCostDecr = oldRenderCost - newRenderCost; 
    573  
    574 #ifdef _DEBUG 
    575         Debug << "old render cost: " << oldRenderCost << endl; 
    576         Debug << "new render cost: " << newRenderCost << endl; 
    577         Debug << "render cost decrease: " << renderCostDecr << endl; 
    578 #endif 
    579  
    580         // take render cost of node into account  
    581         // otherwise danger of being stuck in a local minimum!! 
    582         const float factor = mRenderCostDecreaseWeight; 
    583          
    584         float priority = factor * renderCostDecr + (1.0f - factor) * oldRenderCost; 
    585  
    586         // $$ matt temp 
    587         if (mHierarchyManager->mConsiderMemory) 
    588         { 
    589                 //cout << "here5 rc: " << factor * renderCostDecr << " pvs: " << (1.0f - factor) * splitCandidate.GetPvsEntriesIncr() << endl; 
    590                 //const float priority = factor * renderCostDecr - (1.0f - factor) * (float)splitCandidate.GetPvsEntriesIncr(); 
    591                 priority /= ((float)splitCandidate.GetPvsEntriesIncr() + mHierarchyManager->mMemoryConst); 
    592         } 
    593          
    594         return priority; 
    595558} 
    596559 
Note: See TracChangeset for help on using the changeset viewer.