Ignore:
Timestamp:
10/06/06 21:37:00 (18 years ago)
Author:
mattausch
Message:
 
File:
1 edited

Legend:

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

    r1577 r1580  
    5858        mVspTree->mHierarchyManager = this; 
    5959         
     60        mViewSpaceSubdivisionType = KD_BASED_VIEWSPACE_SUBDIV; 
    6061        ParseEnvironment(); 
    6162} 
     
    7273        mVspTree->mHierarchyManager = this; 
    7374 
     75        mViewSpaceSubdivisionType = KD_BASED_VIEWSPACE_SUBDIV; 
    7476        ParseEnvironment(); 
    7577} 
     
    7880void HierarchyManager::ParseEnvironment() 
    7981{ 
    80         char subdivisionStatsLog[100]; 
    81         Environment::GetSingleton()->GetStringValue("Hierarchy.subdivisionStats",  
    82                 subdivisionStatsLog); 
    83         mSubdivisionStats.open(subdivisionStatsLog); 
    84  
    8582        Environment::GetSingleton()->GetFloatValue( 
    8683                "Hierarchy.Termination.minGlobalCostRatio", mTermMinGlobalCostRatio); 
     
    109106                "Hierarchy.Construction.useMultiLevel", mUseMultiLevelConstruction); 
    110107 
    111          mUseMultiLevelConstruction; 
     108        Environment::GetSingleton()->GetIntValue( 
     109                "Hierarchy.Construction.levels", mNumMultiLevels); 
     110 
    112111        Debug << "******** Hierachy Manager Parameters ***********" << endl; 
    113112        Debug << "max leaves: " << mTermMaxLeaves << endl; 
     
    117116        Debug << "min depth for object space subdivision: " << mMinDepthForObjectSpaceSubdivion << endl; 
    118117        Debug << "repair queue: " << mRepairQueue << endl; 
     118        Debug << "number of multilevels: " << mNumMultiLevels << endl; 
    119119        Debug << endl; 
    120120} 
     
    198198 
    199199 
    200 void HierarchyManager::EvalSubdivisionStats(const SubdivisionCandidate &tData) 
    201 { 
    202         const float costDecr = tData.GetRenderCostDecrease(); 
    203 cout << "here44 " << mHierarchyStats.pvsEntries << endl; 
     200void HierarchyManager::EvalSubdivisionStats(const float renderCostDecr) 
     201{ 
     202        //cout << "pvs entries " << mHierarchyStats.pvsEntries << endl; 
    204203        AddSubdivisionStats(mHierarchyStats.Leaves(), 
    205                                                 costDecr, 
     204                                                renderCostDecr, 
    206205                                                mTotalCost, 
    207                                                 //mPvsEntries 
    208206                                                mHierarchyStats.pvsEntries 
    209207                                                ); 
     
    253251        else 
    254252        { 
     253                char subdivisionStatsLog[100]; 
     254                Environment::GetSingleton()->GetStringValue("Hierarchy.subdivisionStats",  
     255                subdivisionStatsLog); 
     256                mSubdivisionStats.open(subdivisionStatsLog); 
     257 
    255258                ConstructInterleaved(sampleRays, objects, forcedViewSpace); 
    256259        } 
     
    267270 
    268271        mTotalCost = (float)objects.size(); 
     272        EvalSubdivisionStats(0); 
    269273        Debug << "setting total cost to " << mTotalCost << endl; 
    270274 
     
    315319{ 
    316320        cout << "\nstarting view space hierarchy construction ... " << endl; 
    317          // hack: reset global cost misses 
     321        // hack: reset global cost misses 
    318322        mHierarchyStats.mGlobalCostMisses = 0; 
    319  
     323         
    320324        RayInfoContainer *viewSpaceRays = new RayInfoContainer(); 
    321325        SubdivisionCandidate *vsc =  
     
    346350 
    347351void HierarchyManager::PrepareBvHierarchy(const VssRayContainer &sampleRays, 
    348                                                                                   const ObjectContainer &objects)  
    349  
     352                                                                                  const ObjectContainer &objects) 
    350353{ 
    351354        const long startTime = GetTime(); 
     
    387390 
    388391 
    389 bool HierarchyManager::ApplySubdivisionCandidate(SubdivisionCandidate *sc) 
     392bool HierarchyManager::ApplySubdivisionCandidate(SubdivisionCandidate *sc, const bool repairQueue) 
    390393{ 
    391394        const bool globalTerminationCriteriaMet = GlobalTerminationCriteriaMet(sc); 
     
    406409        } 
    407410 
    408         if (vspSplit) 
    409         { 
    410                 VspNode *n = mVspTree->Subdivide(mTQueue, sc, globalTerminationCriteriaMet); 
    411  
    412                 if (n->IsLeaf()) // local or global termination criteria failed 
    413                         return false; 
    414         } 
    415         else 
    416         { 
    417                 if (mObjectSpaceSubdivisionType == KD_BASED_OBJ_SUBDIV) 
    418                 { 
    419                         KdNode *n = mOspTree->Subdivide(mTQueue, sc, globalTerminationCriteriaMet); 
    420                         // local or global termination criteria failed 
    421                         if (n->IsLeaf())  
    422                                 return false; 
    423                 } 
    424                 else if (mObjectSpaceSubdivisionType == BV_BASED_OBJ_SUBDIV) 
    425                 { 
    426                         BvhNode *n = mBvHierarchy->Subdivide(mTQueue, sc, globalTerminationCriteriaMet); 
    427                         // local or global termination criteria failed 
    428                         if (n->IsLeaf()) 
    429                                 return false; 
    430                 } 
     411        bool success; 
     412        switch (sc->Type()) 
     413        { 
     414        case SubdivisionCandidate::VIEW_SPACE: 
     415                { 
     416                        VspNode *n = mVspTree->Subdivide(mTQueue, sc, globalTerminationCriteriaMet); 
     417                        success = !n->IsLeaf(); // local or global termination criteria failed? 
     418                } 
     419                break; 
     420        case SubdivisionCandidate::OBJECT_SPACE: 
     421                { 
     422                        if (mObjectSpaceSubdivisionType == KD_BASED_OBJ_SUBDIV) 
     423                        { 
     424                                KdNode *n = mOspTree->Subdivide(mTQueue, sc, globalTerminationCriteriaMet); 
     425                                // local or global termination criteria failed 
     426                                success = !n->IsLeaf(); 
     427                        } 
     428                        else if (mObjectSpaceSubdivisionType == BV_BASED_OBJ_SUBDIV) 
     429                        { 
     430                                BvhNode *n = mBvHierarchy->Subdivide(mTQueue, sc, globalTerminationCriteriaMet); 
     431                                // local or global termination criteria failed 
     432                                success = !n->IsLeaf();                                  
     433                        } 
     434                } 
     435                break; 
     436        default: 
     437                break; 
     438        } 
     439 
     440        cout << sc->Type() << " "; 
     441                 
     442        // update stats 
     443        mHierarchyStats.nodes += 2; 
     444         
     445        const int pvsEntries = sc->GetPvsEntriesIncr(); 
     446        mHierarchyStats.pvsEntries += pvsEntries; 
     447         
     448        //cout << "pvs entries: " << pvsEntries << " " << mHierarchyStats.pvsEntries << endl; 
     449        mHierarchyStats.memory += 0; // TODO 
     450         
     451        // subdivision successful 
     452        EvalSubdivisionStats(sc->GetRenderCostDecrease()); 
     453                 
     454        // reevaluate candidates affected by the split for view space splits,  
     455        // this would be object space splits and other way round 
     456        if (repairQueue)  
     457        {        
     458                RepairQueue(); 
    431459        } 
    432460 
     
    507535                //-- subdivide leaf node 
    508536 
    509                 if (ApplySubdivisionCandidate(mCurrentCandidate)) 
    510                 { 
    511                         cout << mCurrentCandidate->Type() << " "; 
    512                  
    513                         // update stats 
    514                         mHierarchyStats.nodes += 2; 
    515                         const int pvsEntries = mCurrentCandidate->GetPvsEntriesIncr(); 
    516                         mHierarchyStats.pvsEntries += pvsEntries; 
    517                         cout << "pvs entries: " << pvsEntries << " " << mHierarchyStats.pvsEntries << endl; 
    518                         mHierarchyStats.memory += 0; // TODO 
    519                         // subdivision successful 
    520                         EvalSubdivisionStats(*mCurrentCandidate); 
    521                  
    522                         // reevaluate candidates affected by the split for view space splits,  
    523                         // this would be object space splits and other way round 
    524                         if (repairQueue)  
    525                         {        
    526                                 RepairQueue(); 
    527                         } 
    528                 } 
    529  
     537                ApplySubdivisionCandidate(mCurrentCandidate, repairQueue); 
     538                                 
    530539                // we use objects for evaluating vsp tree construction until  
    531540                // a certain depth once a certain depth existiert ... 
     
    569578{ 
    570579        int i = 0; 
     580        // main loop 
    571581        while (!FinishedConstruction()) 
    572582        { 
    573583                mCurrentCandidate = NextSubdivisionCandidate();     
    574584                         
    575                 /////////////////// 
     585                /////// 
    576586                //-- subdivide leaf node 
    577587 
    578                 if (ApplySubdivisionCandidate(mCurrentCandidate)) 
    579                 { 
    580                         cout << mCurrentCandidate->Type() << " "; 
    581                         if (0) cout << "subdividing candidate " << ++ i << " of type "  
    582                                                 << mCurrentCandidate->Type() << endl; 
    583                         mHierarchyStats.nodes += 2; 
    584  
    585                         // subdivision successful 
    586                         EvalSubdivisionStats(*mCurrentCandidate); 
    587                  
    588                         // reevaluate candidates affected by the split for view space splits,  
    589                         // this would be object space splits and other way round 
    590                         if (repairQueue)  
    591                         { 
    592                                 RepairQueue(); 
    593                         } 
    594                 } 
    595  
     588                ApplySubdivisionCandidate(mCurrentCandidate, repairQueue); 
    596589                DEL_PTR(mCurrentCandidate); 
    597590        } 
     
    601594void HierarchyManager::ResetObjectSpaceSubdivision(const VssRayContainer &sampleRays,  
    602595                                                                                                   const ObjectContainer &objects) 
    603 { 
     596{        
    604597#if 0    
    605598                DEL_PTR(mBvHierarchy); 
     
    609602                PrepareObjectSpaceSubdivision(sampleRays, objects); 
    610603                return; 
    611 #endif 
    612  
     604#else 
     605         
     606        // no object space subdivision yet 
    613607        if (!ObjectSpaceSubdivisionConstructed()) 
    614608        { 
     
    616610        } 
    617611 
     612        // object space partition constructed => reconstruct 
    618613        switch (mObjectSpaceSubdivisionType) 
    619614        { 
    620615        case BV_BASED_OBJ_SUBDIV: 
    621                 cout << "\nreseting bv hierarchy" << endl; 
    622         Debug << "old bv hierarchy:\n " << mBvHierarchy->mBvhStats << endl; 
    623          
    624                 mHierarchyStats.nodes -= mBvHierarchy->mBvhStats.nodes; 
    625                 mTQueue.Push(mBvHierarchy->Reset(sampleRays, objects)); 
    626                 mTotalCost = mBvHierarchy->mTotalCost; 
     616                { 
     617                        cout << "\nreseting bv hierarchy" << endl; 
     618                        Debug << "old bv hierarchy:\n " << mBvHierarchy->mBvhStats << endl; 
     619         
     620                        SubdivisionCandidate *firstCandidate =  
     621                                mBvHierarchy->Reset(sampleRays, objects); 
     622 
     623                        mTQueue.Push(firstCandidate); 
     624                        mTotalCost = mBvHierarchy->mTotalCost; 
     625 
     626                        mHierarchyStats.nodes = 2; 
     627                        mHierarchyStats.pvsEntries = 0; 
     628                        EvalSubdivisionStats(0); 
     629                } 
    627630                break; 
    628631 
     
    633636                break; 
    634637        } 
     638#endif 
    635639} 
    636640 
     
    639643                                                                                                 const ObjectContainer &objects) 
    640644{ 
    641         DEL_PTR(mBvHierarchy); 
    642         mBvHierarchy = new BvHierarchy(); 
    643         mBvHierarchy->mHierarchyManager = this; 
     645        ViewCellsManager *vc = mVspTree->mViewCellsManager; 
     646 
     647        DEL_PTR(mVspTree); 
     648        mVspTree = new VspTree(); 
     649        mVspTree->mHierarchyManager = this; 
     650        mVspTree->mViewCellsManager = vc; 
    644651 
    645652        PrepareViewSpaceSubdivision(sampleRays, objects); 
    646         return; 
     653         
     654        mHierarchyStats.nodes = 2; 
     655        mHierarchyStats.pvsEntries = 0; 
     656        EvalSubdivisionStats(0); 
     657 
    647658} 
    648659 
     
    665676        mVspTree->ComputeBoundingBox(sampleRays, forcedViewSpace); 
    666677 
    667         // use sah for evaluating object space construction for the first run 
     678        // use sah for evaluating osp tree construction  
     679        // in the first iteration of the subdivision 
     680         
    668681        mSavedViewSpaceSubdivisionType = mViewSpaceSubdivisionType; 
    669682        mViewSpaceSubdivisionType = NO_VIEWSPACE_SUBDIV; 
    670          
    671         const int limit = 4; 
     683 
     684        mSavedObjectSpaceSubdivisionType = mObjectSpaceSubdivisionType; 
     685        //mObjectSpaceSubdivisionType = NO_OBJ_SUBDIV; 
     686 
     687        const int limit = mNumMultiLevels; 
    672688        int i = 0; 
    673689 
     
    678694        while (1) 
    679695        { 
    680         // first run object space subdivision 
     696                char subdivisionStatsLog[100]; 
     697                sprintf(subdivisionStatsLog, "tests/i3d/subdivision-%04d.log", i); 
     698                mSubdivisionStats.open(subdivisionStatsLog); 
     699 
     700                // fsubdivide object space first 
    681701                ResetObjectSpaceSubdivision(sampleRays, objects); 
    682  
    683702                // process object space candidates 
    684703                RunConstruction(false); 
    685704 
    686                 if ((++ i) >= limit) 
     705                // object space subdivision constructed 
     706                mObjectSpaceSubdivisionType = mSavedObjectSpaceSubdivisionType; 
     707 
     708                cout << "iteration " << i << " of " << limit << " finished" << endl; 
     709 
     710                mSubdivisionStats.close(); 
     711                if ((i ++) >= limit) 
    687712                        break; 
    688713 
     714                sprintf(subdivisionStatsLog, "tests/i3d/subdivision-%04d.log", i); 
     715                mSubdivisionStats.open(subdivisionStatsLog); 
     716 
    689717                ///////////////// 
    690                 // do view space subdivison with respect to the object space partition 
     718                // subdivide view space with respect to the objects 
     719 
    691720                ResetViewSpaceSubdivision(sampleRays, objects); 
    692  
    693721                // process view space candidates 
    694722                RunConstruction(false); 
     723                // view space subdivision constructed 
    695724                mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType; 
    696                  
    697                 if ((++ i) >= limit) 
     725         
     726                cout << "iteration " << i << " of " << limit << " finished" << endl; 
     727 
     728                mSubdivisionStats.close(); 
     729 
     730                if ((i ++) >= limit) 
    698731                        break; 
    699  
    700                 cout << "iteration " << i << " of " << limit << " finished" << endl; 
    701732        } 
    702733         
     
    729760                return mBvHierarchy && mBvHierarchy->GetRoot(); 
    730761        default: 
    731         return false; 
     762                return false; 
    732763        } 
    733764} 
     
    808839 
    809840        // collect list of "dirty" candidates 
    810         long startTime = GetTime(); 
     841        const long startTime = GetTime(); 
    811842    
    812843        vector<SubdivisionCandidate *> dirtyList; 
     
    827858                sc->EvalPriority(); // reevaluate 
    828859                 
    829                 /* 
     860#ifdef _DEBUG 
    830861                Debug << "candidate " << sc << " reevaluated\n"  
    831862                          << "render cost decrease diff " <<  rcd - sc->GetRenderCostDecrease() 
    832                           << " old: " << rcd << " new " << sc->GetRenderCostDecrease() << endl;*/ 
    833                 if (0) 
    834                 { 
    835                         const float rcDiff =  rcd - sc->GetRenderCostDecrease(); 
    836                         mTotalCost += rcDiff; 
    837                 } 
     863                          << " old: " << rcd << " new " << sc->GetRenderCostDecrease() << endl; 
     864#endif   
    838865                mTQueue.Push(sc); // reinsert 
     866                cout << "."; 
    839867        } 
    840868 
    841869        long endTime = GetTime(); 
    842870        Real timeDiff = TimeDiff(startTime, endTime); 
    843  
    844871        mHierarchyStats.repairTime += timeDiff; 
    845872 
    846         if (0) cout << "finished in " << timeDiff * 1e-3f << " secs" << endl; 
     873        if (1) cout << "repaired in " << timeDiff * 1e-3f << " secs" << endl; 
    847874} 
    848875 
     
    864891        SubdivisionCandidateContainer::const_iterator sit, sit_end = mCandidateBuffer.end(); 
    865892    for (sit = mCandidateBuffer.begin(); sit != sit_end; ++ sit) 
    866         {cout << ":"; 
     893        { 
    867894                mTQueue.Push(*sit); 
    868895        } 
Note: See TracChangeset for help on using the changeset viewer.