Changeset 1308 for GTP


Ignore:
Timestamp:
08/31/06 17:58:27 (18 years ago)
Author:
mattausch
Message:

changed hierarchy construction: up to a certain level view space split is taken

Location:
GTP/trunk/Lib/Vis/Preprocessing/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r1305 r1308  
    13041304                                                                                                           const ObjectContainer &objects) 
    13051305{ 
     1306        mBvhStats.Reset(); 
     1307        mBvhStats.Start(); 
     1308        mBvhStats.nodes = 1; 
     1309 
    13061310        // note matt: we assume that we have objects sorted by their id 
    13071311 

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

    r1305 r1308  
    3636HierarchyManager::HierarchyManager(VspTree *vspTree,  
    3737                                                                   const int objectSpaceSubdivisionType): 
    38 mObjectSpaceSubdivisonType(objectSpaceSubdivisionType), 
     38mObjectSpaceSubdivisionType(objectSpaceSubdivisionType), 
    3939mVspTree(vspTree),  
    4040mOspTree(NULL),  
    4141mBvHierarchy(NULL) 
    4242{ 
    43         switch(mObjectSpaceSubdivisonType) 
     43        switch(mObjectSpaceSubdivisionType) 
    4444        { 
    4545        case KD_BASED_OBJ_SUBDIV: 
    … …  
    6767 
    6868HierarchyManager::HierarchyManager(VspTree *vspTree, KdTree *kdTree):  
    69 mObjectSpaceSubdivisonType(KD_BASED_OBJ_SUBDIV), 
     69mObjectSpaceSubdivisionType(KD_BASED_OBJ_SUBDIV), 
    7070mVspTree(vspTree),  
    7171mBvHierarchy(NULL) 
    … …  
    102102                "Hierarchy.Construction.type", mConstructionType); 
    103103 
     104        mMinDepthForObjectSpaceSubdivion = -1; 
     105 
    104106        Debug << "******** Hierachy Manager Parameters ***********" << endl; 
    105107        Debug << "max leaves: " << mTermMaxLeaves << endl; 
    … …  
    143145 
    144146 
    145 void HierarchyManager::PrepareConstruction(const VssRayContainer &sampleRays, 
    146                                                                                    const ObjectContainer &objects, 
    147                                                                                    AxisAlignedBox3 *forcedViewSpace, 
    148                                                                                    RayInfoContainer &viewSpaceRays, 
    149                                                                                    RayInfoContainer &objectSpaceRays) 
    150 { 
    151         mHierarchyStats.Reset(); 
    152         mHierarchyStats.Start(); 
    153  
    154         switch (mObjectSpaceSubdivisonType) 
    155         { 
    156         case KD_BASED_OBJ_SUBDIV: 
    157                 { 
    158                         SubdivisionCandidate *vsc =  
    159                                 mVspTree->PrepareConstruction(sampleRays, forcedViewSpace, viewSpaceRays); 
    160                         mTQueue.Push(vsc); 
    161  
    162                         SubdivisionCandidate *osc; 
    163                         osc = mOspTree->PrepareConstruction(sampleRays, objects, objectSpaceRays); 
    164                         mTQueue.Push(osc); 
    165                         break; 
    166                 } 
    167         case BV_BASED_OBJ_SUBDIV: 
    168                 { 
    169                         mBvHierarchy->CreateRoot(objects); 
    170  
    171                         SubdivisionCandidate *vsc =  
    172                                 mVspTree->PrepareConstruction(sampleRays, forcedViewSpace, viewSpaceRays); 
    173                         mTQueue.Push(vsc); 
    174  
    175                         SubdivisionCandidate *osc; 
    176                         osc = mBvHierarchy->PrepareConstruction(sampleRays, objects); 
    177                         mTQueue.Push(osc); 
    178                         break; 
    179                 } 
    180         default: 
    181                 break; 
    182         } 
    183  
    184         mTotalCost = (float)objects.size(); 
    185         Debug << "setting total cost to " << mTotalCost << endl; 
    186 } 
    187  
    188  
    189147void HierarchyManager::EvalSubdivisionStats(const SubdivisionCandidate &tData) 
    190148{ 
    191149        const float costDecr = tData.GetRenderCostDecrease(); 
    192150 
    193         switch (mObjectSpaceSubdivisonType) 
     151        switch (mObjectSpaceSubdivisionType) 
    194152        { 
    195153        case KD_BASED_OBJ_SUBDIV: 
    … …  
    219177                                                                                   const float totalRenderCost) 
    220178{ 
    221         mSubdivisionStats  
     179        mSubdivisionStats 
    222180                        << "#Splits\n" << splits << endl 
    223181                        << "#RenderCostDecrease\n" << renderCostDecr << endl  
    … …  
    241199                                                                AxisAlignedBox3 *forcedViewSpace) 
    242200{ 
    243         switch (mConstructionType) 
    244         { 
    245         case 0:  
    246                 ConstructSequential(sampleRays, objects, forcedViewSpace); 
    247                 break; 
    248         case 1: 
    249                 ConstructInterleaved(sampleRays, objects, forcedViewSpace); 
    250                 break; 
    251         default: 
    252                 break; 
    253         } 
    254 } 
    255  
    256  
    257 void HierarchyManager::ConstructInterleaved(const VssRayContainer &sampleRays, 
    258                                                                                         const ObjectContainer &objects, 
    259                                                                                         AxisAlignedBox3 *forcedViewSpace) 
    260 { 
    261         RayInfoContainer *objectSpaceRays = new RayInfoContainer(); 
     201         
    262202        RayInfoContainer *viewSpaceRays = new RayInfoContainer(); 
    263203 
    264         // prepare vsp and osp trees for traversal 
    265         PrepareConstruction(sampleRays,  
    266                                                 objects,  
    267                                                 forcedViewSpace,  
    268                                                 *viewSpaceRays,  
    269                                                 *objectSpaceRays); 
    270  
     204        mHierarchyStats.Reset(); 
     205        mHierarchyStats.Start(); 
     206 
     207        // start with view space subdivison: prepare vsp tree for traversal 
     208        SubdivisionCandidate *vsc =  
     209                mVspTree->PrepareConstruction(sampleRays, forcedViewSpace, *viewSpaceRays); 
     210        mTQueue.Push(vsc); 
     211 
     212        mTotalCost = (float)objects.size(); 
     213        Debug << "setting total cost to " << mTotalCost << endl; 
     214 
     215        const long startTime = GetTime();        
    271216        cout << "Constructing view space / object space tree ... \n"; 
    272         const long startTime = GetTime();        
    273217         
    274         const bool repairQueue = true; 
    275         //const bool repairQueue = false; 
    276  
    277218        // process object space candidates 
    278         RunConstruction(repairQueue); 
     219        RunConstruction(); 
     220         
    279221        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl; 
    280  
    281222        mVspTree->mVspStats.Stop(); 
    282223} 
    283224 
    284225 
    285 void HierarchyManager::ConstructBvHierarchy(const VssRayContainer &sampleRays, 
    286                                                                                         const ObjectContainer &objects)  
    287  
    288 { 
    289         Debug << "\n$$$$$$$$$ bv hierarchy construction $$$$$$$$$$\n" << endl; 
     226void HierarchyManager::PrepareObjectSpaceSubdivision(const VssRayContainer &sampleRays, 
     227                                                                                                         const ObjectContainer &objects) 
     228{ 
     229        if (mObjectSpaceSubdivisionType == KD_BASED_OBJ_SUBDIV) 
     230        { 
     231                PrepareOspTree(sampleRays, objects); 
     232        } 
     233        else if (mObjectSpaceSubdivisionType == BV_BASED_OBJ_SUBDIV) 
     234        { 
     235                PrepareBvHierarchy(sampleRays, objects); 
     236        } 
     237} 
     238 
     239 
     240void HierarchyManager::PrepareBvHierarchy(const VssRayContainer &sampleRays, 
     241                                                                                  const ObjectContainer &objects)  
     242 
     243{ 
    290244        cout << "starting bv hierarchy construction ... " << endl; 
    291245 
    … …  
    298252        mTotalCost = mBvHierarchy->mTotalCost; 
    299253        Debug << "reseting cost, new total cost: " << mTotalCost << endl; 
    300          
     254 
    301255    mTQueue.Push(sc); 
    302  
    303         mBvHierarchy->mBvhStats.Reset(); 
    304         mBvHierarchy->mBvhStats.Start(); 
    305  
    306         const long startTime = GetTime(); 
    307  
    308         const bool repairQueue = false; 
    309         // process object space candidates 
    310         RunConstruction(repairQueue); 
    311  
    312         cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl; 
    313         mBvHierarchy->mBvhStats.Stop(); 
    314 } 
    315  
    316  
    317 void HierarchyManager::ConstructOspTree(const VssRayContainer &sampleRays, 
    318                                                                                 const ObjectContainer &objects)  
    319  
     256} 
     257 
     258 
     259void HierarchyManager::PrepareOspTree(const VssRayContainer &sampleRays, 
     260                                                                          const ObjectContainer &objects) 
    320261{ 
    321262        RayInfoContainer *objectSpaceRays = new RayInfoContainer(); 
    322263 
    323         Debug << "\n$$$$$$$$$ osp tree construction $$$$$$$$$$\n" << endl; 
    324264        cout << "starting osp tree construction ... " << endl; 
    325265 
    … …  
    335275         
    336276    mTQueue.Push(osc); 
    337  
    338         mOspTree->mOspStats.Reset(); 
    339         mOspTree->mOspStats.Start(); 
    340  
    341         const long startTime = GetTime(); 
    342                  
    343         const bool repairQueue = false; 
    344         // process object space candidates 
    345         RunConstruction(repairQueue); 
    346  
    347         cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl; 
    348         mOspTree->mOspStats.Stop(); 
    349  
    350         ////////////////////////// 
    351         // matt: only for debugging purpose 
    352  
    353         const float rc = mOspTree->EvalRenderCost(sampleRays); 
    354         Debug << "My render cost evalulation: " << rc << endl; 
    355 } 
    356  
     277} 
    357278 
    358279 
    … …  
    371292        else 
    372293        { 
    373                 if (mObjectSpaceSubdivisonType == KD_BASED_OBJ_SUBDIV) 
     294                if (mObjectSpaceSubdivisionType == KD_BASED_OBJ_SUBDIV) 
    374295                { 
    375296                        KdNode *n = mOspTree->Subdivide(mTQueue, sc, globalTerminationCriteriaMet); 
    … …  
    378299                                return false; 
    379300                } 
    380                 else if (mObjectSpaceSubdivisonType == BV_BASED_OBJ_SUBDIV) 
     301                else if (mObjectSpaceSubdivisionType == BV_BASED_OBJ_SUBDIV) 
    381302                { 
    382303                        BvhNode *n = mBvHierarchy->Subdivide(mTQueue, sc, globalTerminationCriteriaMet); 
    … …  
    386307                } 
    387308        } 
    388          
    389309        return true;//!globalTerminationCriteriaMet; 
    390310} 
    391311 
    392312 
    393 void HierarchyManager::RunConstruction(const bool repair) 
     313bool HierarchyManager::StartObjectSpaceSubdivision() const 
     314{ 
     315        const bool constructAfterViewSpace = (mConstructionType == 1) && mTQueue.Empty(); 
     316 
     317        return  
     318                NO_OBJ_SUBDIV && 
     319                ((mMinDepthForObjectSpaceSubdivion < 0/*mVspTree->mVspStats.mMaxDepth*/) || constructAfterViewSpace); 
     320} 
     321 
     322 
     323void HierarchyManager::RunConstruction() 
    394324{ 
    395325        mHierarchyStats.nodes = 0; 
    396326        mGlobalCostMisses = 0; 
    397327 
    398         while (!FinishedConstruction()) 
    399         { 
     328        // use objects for evaluating vsp tree construction 
     329        const int savedObjectSpaceSubdivisionType = mObjectSpaceSubdivisionType; 
     330        mObjectSpaceSubdivisionType = NO_OBJ_SUBDIV; 
     331 
     332        //const bool repairQueue = false; 
     333        const bool repairQueue = true; 
     334 
     335        do 
     336        { 
     337                // use objects for evaluating vsp tree construction until a certain depth 
     338                if (StartObjectSpaceSubdivision()) 
     339                { 
     340                        mObjectSpaceSubdivisionType = savedObjectSpaceSubdivisionType; 
     341                        //PrepareObjectSpaceSubdivision(); 
     342                } 
     343 
    400344                mCurrentCandidate = NextSubdivisionCandidate();     
    401345                mTotalCost -= mCurrentCandidate->GetRenderCostDecrease(); 
    … …  
    420364                        // reevaluate candidates affected by the split for view space splits,  
    421365                        // this would be object space splits and other way round 
    422                         if (repair) RepairQueue(); 
    423                 } 
    424                  
     366                        if (repairQueue) RepairQueue(); 
     367                }        
    425368                DEL_PTR(mCurrentCandidate); 
    426369        } 
     370        while (!FinishedConstruction()); 
     371 
     372        mObjectSpaceSubdivisionType = savedObjectSpaceSubdivisionType; 
    427373} 
    428374 
    … …  
    436382void HierarchyManager::CollectObjectSpaceDirtyList(SubdivisionCandidateContainer &dirtyList) 
    437383{ 
    438         switch (mObjectSpaceSubdivisonType) 
     384        switch (mObjectSpaceSubdivisionType) 
    439385        { 
    440386        case KD_BASED_OBJ_SUBDIV: 
    … …  
    485431void HierarchyManager::RepairQueue() 
    486432{ 
    487         // TODO 
    488433        // for each update of the view space partition: 
    489434        // the candidates from object space partition which 
    … …  
    535480{ 
    536481        // the type of the view cells hierarchy 
    537         switch (mObjectSpaceSubdivisonType) 
     482        switch (mObjectSpaceSubdivisionType) 
    538483        { 
    539484        case KD_BASED_OBJ_SUBDIV: 
    … …  
    559504        if (!obj) return false; 
    560505 
    561         switch (mObjectSpaceSubdivisonType) 
     506        switch (mObjectSpaceSubdivisionType) 
    562507        { 
    563508        case NO_OBJ_SUBDIV: 
    … …  
    583528void HierarchyManager::PrintObjectSpaceHierarchyStatistics(ofstream &stream) const 
    584529{ 
    585         switch (mObjectSpaceSubdivisonType) 
     530        switch (mObjectSpaceSubdivisionType) 
    586531        { 
    587532        case KD_BASED_OBJ_SUBDIV: 
    … …  
    604549                                                                                                  const ObjectContainer &objects) const 
    605550{ 
    606         switch (mObjectSpaceSubdivisonType) 
     551        switch (mObjectSpaceSubdivisionType) 
    607552        { 
    608553        case KD_BASED_OBJ_SUBDIV: 
    … …  
    640585 
    641586 
    642 void HierarchyManager::ConstructSequential(const VssRayContainer &sampleRays, 
    643                                                                                    const ObjectContainer &objects, 
    644                                                                                    AxisAlignedBox3 *forcedViewSpace) 
    645 { 
    646         // rays clipped in view space and in object space 
    647         RayInfoContainer *viewSpaceRays = new RayInfoContainer(); 
    648          
    649  
    650         ///////////////////////////////////////////////////////////// 
    651         // view space space partition 
    652         ///////////////////////////////////////////////////////////// 
    653  
    654  
    655         // use objects for evaluating vsp tree construction 
    656         const int savedobjectSpaceSubdivisionType = mObjectSpaceSubdivisonType; 
    657         mObjectSpaceSubdivisonType = NO_OBJ_SUBDIV; 
    658  
    659         SubdivisionCandidate *vsc =  
    660                 mVspTree->PrepareConstruction(sampleRays, forcedViewSpace, *viewSpaceRays); 
    661          
    662         // add to subdivision candidate to split candidate queue 
    663         mTQueue.Push(vsc); 
    664  
    665         long startTime = GetTime(); 
    666         cout << "starting vsp construction ... " << endl; 
    667  
    668         mVspTree->mVspStats.Reset(); 
    669         mVspTree->mVspStats.Start(); 
    670  
    671         // all objects can be seen from everywhere 
    672         mTotalCost = (float)dynamic_cast<VspTree::VspSubdivisionCandidate *>(vsc)->mParentData.mPvs; 
    673  
    674         const bool repairQueue = false; 
    675         // process view space candidates 
    676         RunConstruction(repairQueue); 
    677  
    678         cout << "finished in " << TimeDiff(startTime, GetTime())*1e-3 << " secs" << endl; 
    679         mVspTree->mVspStats.Stop(); 
    680  
    681         // reset subdivision type 
    682         mObjectSpaceSubdivisonType = savedobjectSpaceSubdivisionType; 
    683  
    684  
    685         ///////////////////////////////////////////////////////////// 
    686         // object space partition 
    687         ///////////////////////////////////////////////////////////// 
    688          
    689         switch (mObjectSpaceSubdivisonType) 
    690         { 
    691         case KD_BASED_OBJ_SUBDIV: 
    692                 { 
    693                         ConstructOspTree(sampleRays, objects); 
    694                         break; 
    695                 } 
    696         case BV_BASED_OBJ_SUBDIV: 
    697                 { 
    698                         ConstructBvHierarchy(sampleRays, objects); 
    699                         break; 
    700                 } 
    701         default: 
    702                 break; 
    703         } 
    704 } 
    705  
    706  
    707 } 
     587} 

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

    r1294 r1308  
    150150        ~HierarchyManager(); 
    151151 
    152         void Construct( 
    153                 const VssRayContainer &sampleRays, 
    154                 const ObjectContainer &objects, 
    155                 AxisAlignedBox3 *forcedViewSpace); 
    156  
    157152        /** Constructs the view space and object space subdivision from a given set of rays 
    158153                and a set of objects. 
    … …  
    160155                @param objects the set of objects 
    161156        */ 
    162         void ConstructInterleaved( 
    163                 const VssRayContainer &sampleRays, 
    164                 const ObjectContainer &objects, 
    165                 AxisAlignedBox3 *forcedViewSpace); 
    166  
    167         /** Constructs first view space hierarchy, then object space hierarchy. 
    168         */ 
    169         void ConstructSequential( 
     157        void Construct( 
    170158                const VssRayContainer &sampleRays, 
    171159                const ObjectContainer &objects, 
    … …  
    183171        inline int GetObjectSpaceSubdivisonType() const 
    184172        { 
    185                 return mObjectSpaceSubdivisonType; 
     173                return mObjectSpaceSubdivisionType; 
    186174        } 
    187175         
    … …  
    215203                first split candidates. 
    216204        */ 
    217         void PrepareConstruction( 
    218                 const VssRayContainer &sampleRays, 
    219                 const ObjectContainer &objects, 
    220                 AxisAlignedBox3 *forcedViewSpace, 
    221                 RayInfoContainer &viewSpaceRays, 
    222                 RayInfoContainer &objectSpaceRays); 
    223  
    224         void RunConstruction(const bool repair); 
     205        void PrepareObjectSpaceSubdivision( 
     206                const VssRayContainer &sampleRays, 
     207                const ObjectContainer &objects); 
     208 
     209        void RunConstruction(); 
    225210        bool ApplySubdivisionCandidate(SubdivisionCandidate *sc); 
    226211 
    … …  
    254239 
    255240 
    256         void ConstructBvHierarchy( 
     241        void PrepareBvHierarchy( 
    257242                const VssRayContainer &sampleRays, 
    258243                const ObjectContainer &objects); 
    259244 
    260         void ConstructOspTree( 
     245        void PrepareOspTree( 
    261246                const VssRayContainer &sampleRays, 
    262247                const ObjectContainer &objects); 
    … …  
    264249        void ParseEnvironment(); 
    265250 
     251        bool StartObjectSpaceSubdivision() const; 
     252 
    266253 
    267254protected: 
    268255 
     256        int mObjectSpaceSubdivisionType; 
    269257        int mConstructionType; 
    270         int mObjectSpaceSubdivisonType; 
    271258 
    272259        VspTree *mVspTree; 
    … …  
    290277        HierarchyStatistics mHierarchyStats; 
    291278 
     279        int mMinDepthForObjectSpaceSubdivion; 
     280 
    292281        int mTermMaxLeaves; 
    293282        ofstream mSubdivisionStats; 

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

    r1305 r1308  
    26042604                                                                                                   RayInfoContainer &rays) 
    26052605{        
     2606        mVspStats.Reset(); 
     2607        mVspStats.Start(); 
     2608        mVspStats.nodes = 1; 
     2609 
    26062610        // store pointer to this tree 
    26072611        VspSubdivisionCandidate::sVspTree = this; 
    2608         mVspStats.nodes = 1; 
    2609  
     2612         
    26102613        // compute view space bounding box 
    26112614        ComputeBoundingBox(sampleRays, forcedViewSpace); 
    … …  
    26492652 
    26502653        //-- compute first split candidate 
     2654 
    26512655        VspSubdivisionCandidate *splitCandidate = new VspSubdivisionCandidate(vData); 
    26522656    EvalSubdivisionCandidate(*splitCandidate); 
    … …  
    29692973        if (leaf->Mailed()) // leaf already mailed 
    29702974                return 0; 
    2971  
     2975         
    29722976        leaf->Mail(); 
    29732977 
Note: See TracChangeset for help on using the changeset viewer.