Changeset 1370 for GTP


Ignore:
Timestamp:
09/14/06 18:55:38 (18 years ago)
Author:
mattausch
Message:

debugged global sorting, worked on object-viewspace subdivision

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

Legend:

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

    r1359 r1370  
    1717#include "Beam.h" 
    1818#include "VspTree.h" 
     19#include "HierarchyManager.h" 
    1920 
    2021 
     
    2223 
    2324 
     25#define PROBABILIY_IS_BV_VOLUME 1 
    2426#define USE_FIXEDPOINT_T 0 
    2527 
     
    197199                Randomize(); // initialise random generator for heuristics 
    198200 
     201 
     202        ///////////////////////////////////////////////////////////// 
    199203        //-- termination criteria for autopartition 
    200204        Environment::GetSingleton()->GetIntValue("BvHierarchy.Termination.maxDepth", mTermMaxDepth); 
    201205        Environment::GetSingleton()->GetIntValue("BvHierarchy.Termination.maxLeaves", mTermMaxLeaves); 
    202206        Environment::GetSingleton()->GetIntValue("BvHierarchy.Termination.minObjects", mTermMinObjects); 
     207        Environment::GetSingleton()->GetIntValue("BvHierarchy.Termination.minRays", mTermMinRays); 
    203208        Environment::GetSingleton()->GetFloatValue("BvHierarchy.Termination.minProbability", mTermMinProbability); 
    204209         
    205210        Environment::GetSingleton()->GetIntValue("BvHierarchy.Termination.missTolerance", mTermMissTolerance); 
    206          
     211 
     212 
     213        //////////////////////////////////////////////// 
    207214        //-- max cost ratio for early tree termination 
     215 
    208216        Environment::GetSingleton()->GetFloatValue("BvHierarchy.Termination.maxCostRatio", mTermMaxCostRatio); 
    209  
    210217        Environment::GetSingleton()->GetFloatValue("BvHierarchy.Termination.minGlobalCostRatio", 
    211218                mTermMinGlobalCostRatio); 
     
    213220                mTermGlobalCostMissTolerance); 
    214221 
    215         //-- factors for bsp tree split plane heuristics 
    216  
    217         // if only the driving axis is used for axis aligned split 
     222 
     223        ///////////////////////////////////////// 
     224        //-- factors for subdivision heuristics 
     225 
     226        // if only the driving axis is used for splits 
    218227        Environment::GetSingleton()->GetBoolValue("BvHierarchy.splitUseOnlyDrivingAxis", mOnlyDrivingAxis); 
    219228        Environment::GetSingleton()->GetFloatValue("BvHierarchy.maxStaticMemory", mMaxMemory); 
     
    263272} 
    264273 
     274static int CountRays(const ObjectContainer &objects) 
     275{ 
     276        int nRays = 0; 
     277 
     278        ObjectContainer::const_iterator oit, oit_end = objects.end(); 
     279 
     280        for (oit = objects.begin(); oit != oit_end; ++ oit) 
     281        { 
     282                nRays += (int)(*oit)->mVssRays.size(); 
     283        } 
     284 
     285        return nRays; 
     286} 
    265287 
    266288BvhInterior *BvHierarchy::SubdivideNode(const BvhSubdivisionCandidate &sc, 
     
    268290                                                                                BvhTraversalData &backData) 
    269291{ 
     292        mBvhStats.nodes += 2; // we have two new leaves 
     293 
    270294        const BvhTraversalData &tData = sc.mParentData; 
    271295        BvhLeaf *leaf = tData.mNode; 
    272     mBvhStats.nodes += 2; // we have two new leaves 
     296        AxisAlignedBox3 parentBox = leaf->GetBoundingBox(); 
    273297 
    274298        // add the new nodes to the tree 
    275         BvhInterior *node = new BvhInterior(tData.mBoundingBox, leaf->GetParent()); 
    276          
     299        BvhInterior *node = new BvhInterior(parentBox, leaf->GetParent()); 
     300         
     301 
     302        //////////////////////////////// 
     303        //-- create front and back leaf 
     304 
     305        AxisAlignedBox3 fbox = ComputeBoundingBox(sc.mFrontObjects, &parentBox); 
     306        AxisAlignedBox3 bbox = ComputeBoundingBox(sc.mBackObjects, &parentBox); 
     307 
     308        BvhLeaf *back =  
     309                new BvhLeaf(bbox, node, (int)sc.mBackObjects.size()); 
     310        BvhLeaf *front =  
     311                new BvhLeaf(fbox, node, (int)sc.mFrontObjects.size()); 
     312 
     313        BvhInterior *parent = leaf->GetParent(); 
     314 
     315        // replace a link from node's parent 
     316        if (parent) 
     317        { 
     318                parent->ReplaceChildLink(leaf, node); 
     319                node->SetParent(parent); 
     320        } 
     321        else // no parent => this node is the root 
     322        { 
     323                mRoot = node; 
     324        } 
     325 
     326        // and setup child links 
     327        node->SetupChildLinks(front, back); 
     328 
     329        ++ mBvhStats.splits; 
     330 
    277331 
    278332        /////////////////////////////////////////////////////////////////// 
     
    281335        frontData.mDepth = backData.mDepth = tData.mDepth + 1; 
    282336 
    283         frontData.mBoundingBox = ComputeBoundingBox(sc.mFrontObjects, &tData.mBoundingBox); 
    284         backData.mBoundingBox = ComputeBoundingBox(sc.mBackObjects, &tData.mBoundingBox); 
    285          
    286  
    287         //////////////////////////////// 
    288         //-- create front and back leaf 
    289  
    290         BvhLeaf *back =  
    291                 new BvhLeaf(backData.mBoundingBox, node, (int)sc.mBackObjects.size()); 
    292         BvhLeaf *front =  
    293                 new BvhLeaf(frontData.mBoundingBox, node, (int)sc.mFrontObjects.size()); 
    294  
    295         BvhInterior *parent = leaf->GetParent(); 
    296  
    297         // replace a link from node's parent 
    298         if (parent) 
    299         { 
    300                 parent->ReplaceChildLink(leaf, node); 
    301                 node->SetParent(parent); 
    302         } 
    303         else // no parent => this node is the root 
    304         { 
    305                 mRoot = node; 
    306         } 
    307  
    308         // and setup child links 
    309         node->SetupChildLinks(front, back); 
    310  
    311         ++ mBvhStats.splits; 
    312  
    313         //////////////////////////////////// 
    314         //-- fill traversal data 
    315  
    316337        frontData.mNode = front; 
    317338        backData.mNode = back; 
     
    319340        back->mObjects = sc.mBackObjects; 
    320341        front->mObjects = sc.mFrontObjects; 
     342 
     343        // if the number of rays is too low, no assumptions can be made 
     344        // (=> switch to surface area heuristics?) 
     345        frontData.mNumRays = CountRays(sc.mFrontObjects); 
     346        backData.mNumRays = CountRays(sc.mBackObjects); 
    321347 
    322348        AssociateObjectsWithLeaf(back); 
    323349        AssociateObjectsWithLeaf(front); 
    324350    
     351#if PROBABILIY_IS_BV_VOLUME 
     352        // volume of bvh (= probability that this bvh can be seen) 
     353        frontData.mProbability = fbox.GetVolume(); 
     354        backData.mProbability = bbox.GetVolume(); 
     355#else 
    325356        // compute probability of this node being visible,  
    326357        // i.e., volume of the view cells that can see this node 
    327358        frontData.mProbability = EvalViewCellsVolume(sc.mFrontObjects); 
    328359        backData.mProbability = EvalViewCellsVolume(sc.mBackObjects); 
     360#endif 
    329361 
    330362    // how often was max cost ratio missed in this branch? 
     
    389421                tBackData.mNode->SetSubdivisionCandidate(backCandidate); 
    390422 
    391                 Debug << "leaf: " << tFrontData.mNode << " setting f candidate: "  
    392                           << tFrontData.mNode->GetSubdivisionCandidate() << " type: "  
    393                           << tFrontData.mNode->GetSubdivisionCandidate()->Type() << endl; 
    394  
    395                 Debug << "leaf: " << tBackData.mNode << " setting b candidate: "  
    396                           << tBackData.mNode->GetSubdivisionCandidate() << " type: "  
    397                           << tBackData.mNode->GetSubdivisionCandidate()->Type() << endl; 
    398                  
    399423                tQueue.Push(frontCandidate); 
    400424                tQueue.Push(backCandidate); 
     
    460484        const float renderCostDecr = oldRenderCost - newRenderCost; 
    461485 
    462         Debug << "\nbvh render cost decr: " << renderCostDecr << endl; 
     486        //Debug << "\nbvh render cost decr: " << renderCostDecr << endl; 
    463487        splitCandidate.SetRenderCostDecrease(renderCostDecr); 
    464488 
     
    481505        // matt: TODO 
    482506        return ( 0 
    483                 //|| ((int)data.mNode->mObjects.size() < mTermMinObjects) 
    484                 //|| (data.mProbability <= mTermMinProbability) 
    485                 //|| (data.mDepth >= mTermMaxDepth) 
     507                || ((int)data.mNode->mObjects.size() < mTermMinObjects) 
     508                || (data.mProbability <= mTermMinProbability) 
     509                || (data.mDepth >= mTermMaxDepth) 
     510                || (data.mNumRays <= mTermMinRays) 
    486511                 ); 
    487512} 
     
    493518        return (0 
    494519                || (mBvhStats.Leaves() >= mTermMaxLeaves) 
    495                 //|| (mGlobalCostMisses >= mTermGlobalCostMissTolerance) 
     520                || (mGlobalCostMisses >= mTermGlobalCostMissTolerance) 
    496521                //|| mOutOfMemory  
    497522                ); 
     
    506531        ++ mCreatedLeaves; 
    507532 
     533         
     534        if (data.mProbability <= mTermMinProbability) 
     535        { 
     536                ++ mBvhStats.minProbabilityNodes; 
     537        } 
     538 
     539        //////////////////////////////////////////// 
     540        // depth related stuff 
     541 
     542        if (data.mDepth > mBvhStats.maxDepth) 
     543        { 
     544                mBvhStats.maxDepth = data.mDepth; 
     545        } 
     546 
     547        if (data.mDepth < mBvhStats.minDepth) 
     548        { 
     549                mBvhStats.minDepth = data.mDepth; 
     550        } 
     551 
    508552        if (data.mDepth >= mTermMaxDepth) 
    509553        { 
    510554        ++ mBvhStats.maxDepthNodes; 
    511                 //Debug << "new max depth: " << mVspStats.maxDepthNodes << endl; 
    512         } 
    513  
    514         if (data.mDepth < mTermMaxDepth) 
    515         { 
    516         ++ mBvhStats.minDepthNodes; 
    517         } 
    518  
    519         if (data.mProbability <= mTermMinProbability) 
    520                 ++ mBvhStats.minProbabilityNodes; 
    521          
     555        } 
     556 
    522557        // accumulate depth to compute average depth 
    523558        mBvhStats.accumDepth += data.mDepth; 
    524   
    525         if ((int)(leaf->mObjects.size()) < mTermMinObjects) 
     559 
     560 
     561        //////////////////////////////////////////// 
     562        // objects related stuff 
     563 
     564        // note: this number should always accumulate to the total number of objects 
     565        mBvhStats.objectRefs += (int)leaf->mObjects.size(); 
     566 
     567        if ((int)leaf->mObjects.size() <= mTermMinObjects) 
     568        { 
    526569             ++ mBvhStats.minObjectsNodes; 
    527   
    528         if ((int)(leaf->mObjects.size()) > mBvhStats.maxObjectRefs) 
     570        } 
     571 
     572        if ((int)leaf->mObjects.size() > mBvhStats.maxObjectRefs) 
     573        { 
    529574                mBvhStats.maxObjectRefs = (int)leaf->mObjects.size(); 
     575        } 
     576 
     577        if ((int)leaf->mObjects.size() < mBvhStats.minObjectRefs) 
     578        { 
     579                mBvhStats.minObjectRefs = (int)leaf->mObjects.size(); 
     580        } 
     581 
     582        //////////////////////////////////////////// 
     583        // ray related stuff 
     584 
     585        // note: this number should always accumulate to the total number of rays 
     586        mBvhStats.rayRefs += data.mNumRays; 
     587         
     588        if (data.mNumRays <= mTermMinRays) 
     589        { 
     590             ++ mBvhStats.minRaysNodes; 
     591        } 
     592 
     593        if (data.mNumRays > mBvhStats.maxRayRefs) 
     594        { 
     595                mBvhStats.maxRayRefs = data.mNumRays; 
     596        } 
     597 
     598        if (data.mNumRays < mBvhStats.minRayRefs) 
     599        { 
     600                mBvhStats.minRayRefs = data.mNumRays; 
     601        } 
     602 
     603        cout << "depth: " << data.mDepth << " objects: " << (int)leaf->mObjects.size()  
     604                 << " rays: " << data.mNumRays << " rays / objects "  
     605                 << (float)data.mNumRays / (float)leaf->mObjects.size() << endl; 
    530606} 
    531607 
    532608 
    533609#if 0 
     610 
     611/// compute object boundaries using spatial mid split 
    534612float BvHierarchy::EvalLocalObjectPartition(const BvhTraversalData &tData, 
    535613                                                                                        const int axis, 
     
    553631                // object mailed => belongs to back objects 
    554632                if (objMid < midPoint)  
     633                { 
    555634                        objectsBack.push_back(obj); 
     635                } 
    556636                else 
     637                { 
    557638                        objectsFront.push_back(obj); 
    558         } 
    559  
    560         const float oldRenderCost = tData.mProbability * (float)tData.mNode->mObjects.size(); 
     639                } 
     640        } 
     641 
     642        const float oldProp = EvalViewCellsVolume(tData.mNode->mObjects); 
     643        //const float oldProp = tData.mProbability; 
     644 
     645        const float oldRenderCost = oldProb * (float)tData.mNode->mObjects.size(); 
    561646        const float newRenderCost =  
    562647                EvalRenderCost(tData, objectsFront, objectsBack); 
     
    568653#else 
    569654 
     655/// compute object partition by getting balanced objects on the left and right side 
    570656float BvHierarchy::EvalLocalObjectPartition(const BvhTraversalData &tData, 
    571657                                                                                        const int axis, 
     
    592678 
    593679        const float oldProp = EvalViewCellsVolume(tData.mNode->mObjects); 
    594         //const float oldProp2 = tData.mProbability; 
     680        //const float oldProp = tData.mProbability; 
    595681 
    596682        const float oldRenderCost = oldProp * (float)tData.mNode->mObjects.size(); 
     
    649735 
    650736        vector<float>::const_iterator bit = bordersRight.begin(); 
    651  
     737        cout << "here42" << endl; 
    652738        SortableEntryContainer::const_iterator cit, cit_end = mSubdivisionCandidates->end(); 
    653739        for (cit = mSubdivisionCandidates->begin(); cit != cit_end; ++ cit, ++ bit)  
     
    671757                const float sum = objectsLeft * lbox.SurfaceArea() + objectsRight * rbox.SurfaceArea(); 
    672758       
    673             // cout<<"pos="<<(*ci).value<<"\t q=("<<ql<<","<<qr<<")\t r=("<<rl<<","<<rr<<")"<<endl; 
    674             // cout<<"cost= "<<sum<<endl; 
     759                cout << "pos=" << (*cit).mPos << "\t q=(" << objectsLeft << "," << objectsRight <<")\t r=("  
     760                         << lbox.SurfaceArea() << "," << rbox.SurfaceArea() << ")" << endl; 
     761            cout << "cost= " << sum << endl; 
    675762       
    676763                if (sum < minSum)  
    677764                { 
    678765                        minSum = sum;    
    679                         // objects belongs to left side now 
     766                        // objects belong to left side now 
    680767                        for (; currentPos != (cit + 1); ++ currentPos); 
    681768                } 
    682769        } 
    683770 
     771        //////////////////////////////////////////// 
    684772        //-- assign object to front and back volume 
    685773 
     
    796884        { 
    797885                Intersectable *object = (*cit).mObject; 
    798                  
     886         
    799887                // evaluate change in l and r volume 
    800888                // voll = view cells that see only left node (i.e., left pvs) 
     
    864952{ 
    865953        //-- insert object queries 
    866         ObjectContainer *objects; 
    867  
    868         if (!mUseGlobalSorting) 
    869                 objects = &tData.mNode->mObjects; 
    870         else 
    871                 objects = tData.mSortedObjects[axis]; 
    872          
    873         CreateLocalSubdivisionCandidates(*objects, &mSubdivisionCandidates, mUseGlobalSorting, axis); 
     954        ObjectContainer *objects = mUseGlobalSorting ? tData.mSortedObjects[axis] : &tData.mNode->mObjects; 
     955 
     956        CreateLocalSubdivisionCandidates(*objects, &mSubdivisionCandidates, !mUseGlobalSorting, axis); 
    874957} 
    875958 
     
    9371020        } 
    9381021 
    939         // mail the objects on the left side 
    940         Intersectable::NewMail(); 
    941         // mail view cells on the left side 
     1022        // we will mail view cells switching to the back side 
    9421023        ViewCell::NewMail(); 
    9431024         
     
    10091090        ObjectContainer nFrontObjects[3]; 
    10101091        ObjectContainer nBackObjects[3]; 
    1011  
    10121092        float nCostRatio[3]; 
    10131093 
    1014         // create bounding box of node geometry 
    1015         AxisAlignedBox3 box = tData.mBoundingBox; 
    1016                  
    10171094        int sAxis = 0; 
    10181095        int bestAxis = -1; 
     
    10201097        if (mOnlyDrivingAxis) 
    10211098        { 
     1099                const AxisAlignedBox3 box = tData.mNode->GetBoundingBox(); 
    10221100                sAxis = box.Size().DrivingAxis(); 
    10231101        } 
     
    10321110                        if (mUseCostHeuristics) 
    10331111                        { 
    1034                                 //-- partition objects using heuristics 
    1035                                 nCostRatio[axis] = 
    1036                                         EvalLocalCostHeuristics( 
    1037                                                                                         tData, 
    1038                                                                                         axis, 
    1039                                                                                         nFrontObjects[axis], 
    1040                                                                                         nBackObjects[axis]); 
     1112                                ////////////////////////////////// 
     1113                //-- split objects using heuristics 
     1114                                 
     1115                                if (mHierarchyManager->GetViewSpaceSubdivisionType() ==  
     1116                                        HierarchyManager::KD_BASED_VIEWSPACE_SUBDIV) 
     1117                                { 
     1118                                        //-- heuristics using objects weighted by view cells volume 
     1119                                        nCostRatio[axis] = 
     1120                                                EvalLocalCostHeuristics( 
     1121                                                                                                tData, 
     1122                                                                                                axis, 
     1123                                                                                                nFrontObjects[axis], 
     1124                                                                                                nBackObjects[axis]); 
     1125                                } 
     1126                                else 
     1127                                { 
     1128                                        //-- use surface area heuristic because view cells not constructed yet                           
     1129                                        nCostRatio[axis] = 
     1130                                                EvalLocalCostHeuristics( 
     1131                                                                                                tData, 
     1132                                                                                                axis, 
     1133                                                                                                nFrontObjects[axis], 
     1134                                                                                                nBackObjects[axis]); 
     1135                                } 
    10411136                        } 
    10421137                        else 
    10431138                        { 
     1139                                //-- split objects using some simple criteria 
     1140 
    10441141                                nCostRatio[axis] = 
    10451142                                        EvalLocalObjectPartition( 
     
    10721169 
    10731170 
    1074 void BvHierarchy::AssociateObjectsWithRays(const VssRayContainer &rays) 
    1075 { 
    1076  
     1171int BvHierarchy::AssociateObjectsWithRays(const VssRayContainer &rays) const 
     1172{ 
     1173        int nRays = 0; 
    10771174        VssRayContainer::const_iterator rit, rit_end = rays.end(); 
     1175 
     1176        VssRay::NewMail(); 
    10781177 
    10791178    for (rit = rays.begin(); rit != rays.end(); ++ rit) 
     
    10841183                { 
    10851184                        ray->mTerminationObject->mVssRays.push_back(ray); 
    1086                 } 
    1087  
    1088                 if (0 && ray->mOriginObject) 
     1185                        if (!ray->Mailed()) 
     1186                        { 
     1187                                ray->Mail(); 
     1188                                ++ nRays; 
     1189                        } 
     1190                } 
     1191 
     1192                if (1 && ray->mOriginObject) 
    10891193                { 
    10901194                        ray->mOriginObject->mVssRays.push_back(ray); 
    1091                 } 
    1092         } 
     1195 
     1196                        if (!ray->Mailed()) 
     1197                        { 
     1198                                ray->Mail(); 
     1199                                ++ nRays; 
     1200                        } 
     1201                } 
     1202        } 
     1203 
     1204        return nRays; 
    10931205} 
    10941206 
     
    11371249                                                                  const ObjectContainer &objectsBack) const 
    11381250{ 
    1139         BvhLeaf *leaf = tData.mNode; 
    1140  
    11411251        // probability that view point lies in a view cell which sees this node 
    11421252        const float pFront = EvalViewCellsVolume(objectsFront); 
    11431253        const float pBack = EvalViewCellsVolume(objectsBack); 
    11441254                 
    1145         const int totalObjects = (int)leaf->mObjects.size(); 
    1146         const int nObjectsFront = (int)objectsFront.size(); 
    1147         const int nObjectsBack = (int)objectsBack.size(); 
    1148  
    11491255        //-- pvs rendering heuristics 
    1150         const float newRenderCost = nObjectsFront * pFront + nObjectsBack * pBack; 
     1256        const float newRenderCost = (int)objectsFront.size() * pFront + (int)objectsBack.size() * pBack; 
    11511257 
    11521258#ifdef _DEBUG 
     
    11711277        ObjectContainer::const_iterator oit, oit_end = objects.end(); 
    11721278 
    1173         //-- compute bounding box 
    11741279        for (oit = objects.begin(); oit != oit_end; ++ oit) 
    11751280        { 
    11761281                Intersectable *obj = *oit; 
    11771282 
    1178                 // compute bounding box of view space 
     1283                // grow bounding box to include all objects 
    11791284                box.Include(obj->GetBox()); 
    11801285        } 
     
    14961601        BvhSubdivisionCandidate::sBvHierarchy = this; 
    14971602        mBvhStats.nodes = 1; 
     1603        mGlobalCostMisses = 0; 
    14981604 
    14991605        // compute bounding box from objects 
     
    15021608        BvhLeaf *bvhleaf = dynamic_cast<BvhLeaf *>(mRoot); 
    15031609 
     1610        // multiply termination criterium for comparison, 
     1611        // so it can be set between zero and one and 
     1612        // no division is necessary during traversal 
     1613 
     1614#if PROBABILIY_IS_BV_VOLUME 
    15041615        mTermMinProbability *= mBoundingBox.GetVolume(); 
    1505         mGlobalCostMisses = 0; 
    1506          
     1616        // probability that bounding volume is seen 
     1617        const float prop = GetBoundingBox().GetVolume(); 
     1618#else 
     1619        mTermMinProbability *= mVspTree->GetBoundingBox().GetVolume(); 
     1620        // probability that volume is "seen" from the view cells 
     1621        const float prop = EvalViewCellsVolume(objects); 
     1622#endif 
     1623 
    15071624        // only rays intersecting objects in node are interesting 
    1508         AssociateObjectsWithRays(sampleRays); 
    1509          
    1510         // probabilty is voume of all "seen" view cells 
    1511 #if 1 
    1512         const float prop = EvalViewCellsVolume(objects); 
    1513 #else 
    1514         const float prop = GetBoundingBox().GetVolume(); 
    1515 #endif 
     1625        const int nRays = AssociateObjectsWithRays(sampleRays); 
     1626        //Debug << "using " << nRays << " of " << (int)sampleRays.size() << " rays" << endl; 
    15161627 
    15171628        // create bvh traversal data 
    1518         BvhTraversalData oData(bvhleaf, 0, mBoundingBox, prop); 
     1629        BvhTraversalData oData(bvhleaf, 0, prop, nRays); 
    15191630 
    15201631        // create sorted object lists for the first data 
     
    15401651 
    15411652        return oSubdivisionCandidate; 
    1542 } 
    1543  
    1544  
    1545 bool BvHierarchy::AddLeafToPvs(BvhLeaf *leaf,  
    1546                                                            ViewCell *vc,  
    1547                                                            const float pdf,  
    1548                                                            float &contribution) 
    1549 { 
    1550         // add kd intersecable to pvs 
    1551         BvhIntersectable *bvhObj = GetOrCreateBvhIntersectable(leaf); 
    1552          
    1553         return vc->AddPvsSample(bvhObj, pdf, contribution); 
    15541653} 
    15551654 
     
    16021701                backData.mSortedObjects[i]->reserve((int)sc.mFrontObjects.size()); 
    16031702 
    1604                 ObjectContainer::const_iterator oit, oit_end = sc.mParentData.mNode->mObjects.end(); 
    1605  
    1606                 for (oit = sc.mParentData.mNode->mObjects.begin(); oit != oit_end; ++ oit) 
     1703                ObjectContainer::const_iterator oit, oit_end = sc.mParentData.mSortedObjects[i]->end(); 
     1704 
     1705                for (oit = sc.mParentData.mSortedObjects[i]->begin(); oit != oit_end; ++ oit) 
    16071706                { 
    16081707                        if ((*oit)->Mailed()) 
     
    16351734        app << "#AXIS_ALIGNED_SPLITS (number of axis aligned splits)\n" << splits << endl; 
    16361735 
    1637         app << "#N_PMINDEPTHLEAVES ( Percentage of leaves at minimum depth )\n"  
    1638                 <<      minDepthNodes * 100 / (double)Leaves() << endl; 
    1639  
     1736        app << "#N_MAXCOSTNODES  ( Percentage of leaves with terminated because of max cost ratio )\n" 
     1737                << maxCostNodes * 100 / (double)Leaves() << endl; 
     1738 
     1739        app << "#N_PMINPROBABILITYLEAVES  ( Percentage of leaves with mininum probability )\n" 
     1740                << minProbabilityNodes * 100 / (double)Leaves() << endl; 
     1741 
     1742 
     1743        ////////////////////////////////////////////////// 
     1744         
    16401745        app << "#N_PMAXDEPTHLEAVES ( Percentage of leaves at maximum depth )\n"  
    16411746                <<      maxDepthNodes * 100 / (double)Leaves() << endl; 
    1642  
    1643         app << "#N_MAXCOSTNODES  ( Percentage of leaves with terminated because of max cost ratio )\n" 
    1644                 << maxCostNodes * 100 / (double)Leaves() << endl; 
    1645  
    1646         app << "#N_PMINPROBABILITYLEAVES  ( Percentage of leaves with mininum probability )\n" 
    1647                 << minProbabilityNodes * 100 / (double)Leaves() << endl; 
    1648  
     1747         
     1748        app << "#N_PMAXDEPTH ( Maximal reached depth )\n" << maxDepth << endl; 
     1749 
     1750        app << "#N_PMINDEPTH ( Minimal reached depth )\n" << minDepth << endl; 
     1751 
     1752        app << "#AVGDEPTH ( average depth )\n" << AvgDepth() << endl; 
     1753 
     1754         
     1755        //////////////////////////////////////////////////////// 
     1756         
    16491757        app << "#N_PMINOBJECTSLEAVES  ( Percentage of leaves with mininum objects )\n" 
    16501758                << minObjectsNodes * 100 / (double)Leaves() << endl; 
    16511759 
    1652         app << "#N_PMAXDEPTH ( Maximal reached depth )\n" << maxDepth << endl; 
    1653  
    1654         app << "#N_PMINDEPTH ( Minimal reached depth )\n" << minDepth << endl; 
    1655  
    1656         app << "#AVGDEPTH ( average depth )\n" << AvgDepth() << endl; 
    1657  
    1658         app << "#N_INVALIDLEAVES (number of invalid leaves )\n" << invalidLeaves << endl; 
    1659  
    16601760        app << "#N_MAXOBJECTREFS  ( Max number of object refs / leaf )\n" << maxObjectRefs << "\n"; 
    16611761 
    1662         //app << "#N_RAYS (number of rays / leaf)\n" << AvgRays() << endl; 
    1663          
    1664         app << "========== END OF VspTree statistics ==========\n"; 
    1665 } 
    1666  
    1667  
    1668 } 
     1762        app << "#N_MINOBJECTREFS  ( Min number of object refs / leaf )\n" << minObjectRefs << "\n"; 
     1763         
     1764        app << "#N_PAVGOBJECTSLEAVES  ( average object refs / leaf)\n" << AvgObjectRefs() << endl; 
     1765 
     1766 
     1767        //////////////////////////////////////////////////////// 
     1768         
     1769        app << "#N_PMINRAYSLEAVES  ( Percentage of leaves with mininum rays )\n" 
     1770                << minRaysNodes * 100 / (double)Leaves() << endl; 
     1771 
     1772        app << "#N_MAXRAYREFS  ( Max number of ray refs / leaf )\n" << maxRayRefs << "\n"; 
     1773 
     1774        app << "#N_MINRAYREFS  ( Min number of ray refs / leaf )\n" << minRayRefs << "\n"; 
     1775         
     1776        app << "#N_PAVGRAYLEAVES  ( average ray refs / leaf )\n" << AvgRayRefs() << endl; 
     1777         
     1778        app << "#N_PAVGRAYCONTRIBLEAVES  ( Average ray contribution)\n" << 
     1779                rayRefs / (double)objectRefs << endl; 
     1780 
     1781        app << "#N_PMAXRAYCONTRIBLEAVES  ( Percentage of leaves with maximal ray contribution )\n"<< 
     1782                maxRayContriNodes * 100 / (double)Leaves() << endl; 
     1783 
     1784        app << "========== END OF BvHierarchy statistics ==========\n"; 
     1785} 
     1786 
     1787 
     1788} 
  • GTP/trunk/Lib/Vis/Preprocessing/src/BvHierarchy.h

    r1357 r1370  
    3535class VspTree; 
    3636class ViewCellsContainer; 
     37class HierarchyManager; 
    3738 
    3839 
     
    4243{ 
    4344public: 
     45         
     46        /// Constructor 
     47        BvhStatistics()  
     48        { 
     49                Reset(); 
     50        } 
     51 
     52        int Nodes() const {return nodes;} 
     53        int Interior() const { return nodes / 2; } 
     54        int Leaves() const { return (nodes / 2) + 1; } 
     55         
     56        double AvgDepth() const  
     57        { return accumDepth / (double)Leaves(); }  
     58 
     59        double AvgObjectRefs() const  
     60        { return objectRefs / (double)Leaves(); }  
     61 
     62        double AvgRayRefs() const  
     63        { return rayRefs / (double)Leaves(); }  
     64 
     65 
     66        void Reset()  
     67        { 
     68                nodes = 0; 
     69                splits = 0; 
     70                maxDepth = 0; 
     71                minDepth = 99999; 
     72                accumDepth = 0; 
     73        maxDepthNodes = 0; 
     74                minProbabilityNodes = 0; 
     75                maxCostNodes = 0; 
     76                         
     77                /////////////////// 
     78                minObjectsNodes = 0; 
     79                maxObjectRefs = 0; 
     80                minObjectRefs = 999999999; 
     81                objectRefs = 0; 
     82 
     83                /////////////////// 
     84                minRaysNodes = 0; 
     85                maxRayRefs = 0; 
     86                minRayRefs = 999999999; 
     87                rayRefs = 0; 
     88                maxRayContriNodes = 0; 
     89        } 
     90 
     91 
     92public: 
     93 
    4494        // total number of nodes 
    4595        int nodes; 
     
    52102        // max depth nodes 
    53103        int maxDepthNodes; 
    54         // minimum depth nodes 
    55         int minDepthNodes; 
    56         // nodes with minimum objects 
    57         int minObjectsNodes; 
     104        // accumulated depth (used to compute average) 
     105        int accumDepth; 
    58106        // minimum area nodes 
    59107        int minProbabilityNodes; 
    60108        /// nodes termination because of max cost ratio; 
    61109        int maxCostNodes; 
     110 
     111        /////////////////////////// 
     112        // nodes with minimum objects 
     113        int minObjectsNodes; 
    62114        // max number of rays per node 
    63115        int maxObjectRefs; 
    64         /// number of invalid leaves 
    65         int invalidLeaves; 
    66         /// accumulated number of rays refs 
    67         //int accumRays; 
    68         // accumulated depth (used to compute average) 
    69         int accumDepth; 
     116        // min number of rays per node 
     117        int minObjectRefs; 
    70118        /// object references 
    71119        int objectRefs; 
    72120 
    73         // Constructor 
    74         BvhStatistics()  
    75         { 
    76                 Reset(); 
    77         } 
    78  
    79         int Nodes() const {return nodes;} 
    80         int Interior() const { return nodes / 2; } 
    81         int Leaves() const { return (nodes / 2) + 1; } 
    82          
    83         // TODO: computation wrong 
    84         double AvgDepth() const  
    85         { return accumDepth / (double)Leaves(); }  
    86  
    87         void Reset()  
    88         { 
    89                 nodes = 0; 
    90                 splits = 0; 
    91                  
    92                 maxDepth = 0; 
    93                 minDepth = 99999; 
    94                 accumDepth = 0; 
    95         maxDepthNodes = 0; 
    96                 minObjectsNodes = 0; 
    97                 minProbabilityNodes = 0; 
    98                 maxCostNodes = 0; 
    99                 invalidLeaves = 0; 
    100                 maxObjectRefs = 0; 
    101                 objectRefs = 0; 
    102         } 
     121 
     122        ////////////////////////// 
     123        // nodes with minimum rays 
     124        int minRaysNodes; 
     125        // max number of rays per node 
     126        int maxRayRefs; 
     127        // min number of rays per node 
     128        int minRayRefs; 
     129        /// object references 
     130        int rayRefs; 
     131        /// nodes with max ray contribution 
     132        int maxRayContriNodes; 
    103133 
    104134        void Print(ostream &app) const; 
     
    298328                mProbability(0.0), 
    299329                mMaxCostMisses(0),  
    300                 mAxis(0) 
     330                mAxis(0), 
     331                mNumRays(0) 
    301332                { 
    302333                        mSortedObjects[0] = mSortedObjects[1] = mSortedObjects[2] = NULL; 
     
    305336                BvhTraversalData(BvhLeaf *node,  
    306337                                                 const int depth, 
    307                                                  const AxisAlignedBox3 &box, 
    308                                                  const float v): 
     338                                                 const float v, 
     339                                                 const int numRays): 
    309340                mNode(node),  
    310341                mDepth(depth), 
    311                 mBoundingBox(box), 
     342                //mBoundingBox(box), 
    312343                mProbability(v), 
    313344                mMaxCostMisses(0), 
    314                 mAxis(0) 
     345                mAxis(0), 
     346                mNumRays(numRays) 
    315347                { 
    316348                        mSortedObjects[0] = mSortedObjects[1] = mSortedObjects[2] = NULL; 
     
    322354                { 
    323355                        DEL_PTR(mNode); 
    324                         /*DEL_PTR(mSortedObjects[0]); 
     356                        DEL_PTR(mSortedObjects[0]); 
    325357                        DEL_PTR(mSortedObjects[1]); 
    326                         DEL_PTR(mSortedObjects[2]);*/ 
     358                        DEL_PTR(mSortedObjects[2]); 
    327359                } 
    328360 
     
    334366                float mProbability; 
    335367                /// the bounding box of the node 
    336                 AxisAlignedBox3 mBoundingBox; 
     368                //AxisAlignedBox3 mBoundingBox; 
    337369                /// how often this branch has missed the max-cost ratio 
    338370                int mMaxCostMisses; 
    339371                /// current axis 
    340372                int mAxis; 
     373                /// number of rays 
     374                int mNumRays; 
    341375                /// the sorted objects for the three dimensions 
    342376                ObjectContainer *mSortedObjects[3];              
     
    496530                ViewCellContainer &viewCells) const; 
    497531 
    498  
    499532        /** Returns leaf the point pt lies in, starting from root. 
    500533        */ 
    501534        BvhLeaf *GetLeaf(Intersectable *obj, BvhNode *root = NULL) const; 
    502535 
     536        /** Sets a pointer to the view cells tree. 
     537        */ 
    503538        ViewCellsTree *GetViewCellsTree() const { return mViewCellsTree; } 
    504          
     539        /** See Get 
     540        */ 
    505541        void SetViewCellsTree(ViewCellsTree *vt) { mViewCellsTree = vt; } 
    506542 
    507         /** Add the bvh leaf to the pvs of the view cell. 
    508         */ 
    509         bool AddLeafToPvs( 
    510                 BvhLeaf *leaf,  
    511                 ViewCell *vc,  
    512                 const float pdf,  
    513                 float &contribution); 
    514543 
    515544protected: 
     
    668697        float PrepareHeuristics(const BvhTraversalData &tData, const int axis); 
    669698         
    670  
    671699        //////////////////////////////////////////////// 
    672700 
     
    678706                const AxisAlignedBox3 *parentBox = NULL); 
    679707 
     708        /** Collects list of invalid candidates. Candidates 
     709                are invalidated by a view space subdivision step 
     710                that affects this candidate. 
     711        */ 
    680712        void CollectDirtyCandidates( 
    681713                BvhSubdivisionCandidate *sc, 
     
    708740        void PrintSubdivisionStats(const SubdivisionCandidate &tData); 
    709741 
     742        /** Prints out the stats for this subdivision. 
     743        */ 
    710744        void AddSubdivisionStats( 
    711745                const int viewCells, 
     
    713747                const float totalRenderCost); 
    714748 
    715         void AssociateObjectsWithRays(const VssRayContainer &rays); 
    716  
     749        /** Stores rays with objects that see the rays. 
     750        */ 
     751        int AssociateObjectsWithRays(const VssRayContainer &rays) const; 
     752 
     753        /** Tests if object is in this leaf. 
     754                @note: assumes that objects are sorted by their id. 
     755        */ 
    717756        bool IsObjectInLeaf(BvhLeaf *, Intersectable *object) const; 
    718757 
     758        /** Prepares the construction of the bv hierarchy and returns 
     759                the first subdivision candidate. 
     760        */ 
    719761        SubdivisionCandidate *PrepareConstruction( 
    720762                const VssRayContainer &sampleRays, 
    721                 const ObjectContainer &objects 
    722                 ); 
    723  
     763                const ObjectContainer &objects); 
     764 
     765        /** Evaluates volume of view cells that see the objects. 
     766        */ 
    724767        float EvalViewCellsVolume(const ObjectContainer &objects) const; 
    725768 
     769        /** Creates initial list of sorted objects. 
     770        */ 
    726771        void CreateInitialSortedObjectList(BvhTraversalData &tData); 
    727772 
     773        /** Assigns sorted objects to front and back data. 
     774        */ 
    728775        void AssignSortedObjects( 
    729776                const BvhSubdivisionCandidate &sc, 
     
    736783        /// pre-sorted subdivision candidtes for all three directions. 
    737784        vector<SortableEntry> *mGlobalSubdivisionCandidates[3]; 
    738  
    739785        /// pointer to the hierarchy of view cells 
    740786        ViewCellsTree *mViewCellsTree; 
    741  
     787        /// pointer to the view space partition tree 
    742788        VspTree *mVspTree; 
    743  
    744789        /// The view cells manager 
    745790        ViewCellsManager *mViewCellsManager; 
    746  
    747791        /// candidates for placing split planes during cost heuristics 
    748792        vector<SortableEntry> *mSubdivisionCandidates; 
    749  
    750793        /// Pointer to the root of the tree 
    751794        BvhNode *mRoot; 
    752                  
    753795        /// Statistics for the object space partition 
    754         BvhStatistics mBvhStats; 
    755          
     796        BvhStatistics mBvhStats;         
    756797        /// box around the whole view domain 
    757798        AxisAlignedBox3 mBoundingBox; 
     799        /// the hierarchy manager 
     800        HierarchyManager *mHierarchyManager; 
    758801 
    759802 
     
    767810        /// minimal number of objects 
    768811        int mTermMinObjects; 
    769         /// maximal contribution per ray 
    770         float mTermMaxRayContribution; 
    771812        /// maximal acceptable cost ratio 
    772813        float mTermMaxCostRatio; 
    773814        /// tolerance value indicating how often the max cost ratio can be failed 
    774815        int mTermMissTolerance; 
     816        /// minimum number of rays 
     817        int mTermMinRays; 
    775818 
    776819 
  • GTP/trunk/Lib/Vis/Preprocessing/src/Environment.cpp

    r1359 r1370  
    23452345                                        "0.00001"); 
    23462346 
     2347        RegisterOption("BvHierarchy.Termination.minRays", 
     2348                                        optInt, 
     2349                                        "bvh_term_min_rays=", 
     2350                                        "0"); 
     2351 
    23472352        RegisterOption("BvHierarchy.Termination.missTolerance", 
    23482353                                        optInt, 
     
    24362441                                        "-1"); 
    24372442 
     2443        RegisterOption("Hierarchy.Construction.startWithObjectSpace", 
     2444                                        optBool, 
     2445                                        "hierarchy_construction_start_with_osp=", 
     2446                                        "true"); 
     2447 
    24382448        RegisterOption("Hierarchy.Construction.repairQueue", 
    24392449                                        optBool, 
     
    24412451                                        "true"); 
    24422452 
     2453        RegisterOption("Hierarchy.Construction.minDepthForVsp", 
     2454                                        optInt, 
     2455                                        "hierarchy_construction_min_depth_for_vsp=", 
     2456                                        "-1"); 
    24432457 
    24442458        ////////////////////////////////////////////////////////////////////////////////// 
  • GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.cpp

    r1344 r1370  
    9595                "Hierarchy.Termination.globalCostMissTolerance", mTermGlobalCostMissTolerance); 
    9696 
     97        Environment::GetSingleton()->GetBoolValue( 
     98                "Hierarchy.Construction.startWithObjectSpace", mStartWithObjectSpace); 
     99 
    97100        Environment::GetSingleton()->GetIntValue( 
    98101                "Hierarchy.Termination.maxLeaves", mTermMaxLeaves); 
     
    103106        Environment::GetSingleton()->GetIntValue( 
    104107                "Hierarchy.Construction.minDepthForOsp", mMinDepthForObjectSpaceSubdivion); 
     108 
     109        Environment::GetSingleton()->GetIntValue( 
     110                "Hierarchy.Construction.minDepthForVsp", mMinDepthForViewSpaceSubdivion); 
    105111         
    106112        Environment::GetSingleton()->GetBoolValue( 
     
    125131 
    126132 
     133int HierarchyManager::GetObjectSpaceSubdivisionType() const 
     134{ 
     135        return mObjectSpaceSubdivisionType; 
     136} 
     137 
     138 
     139int HierarchyManager::GetViewSpaceSubdivisionType() const 
     140{ 
     141        return mViewSpaceSubdivisionType; 
     142} 
     143 
     144 
    127145void HierarchyManager::SetViewCellsManager(ViewCellsManager *vcm) 
    128146{ 
     
    220238        mObjectSpaceSubdivisionType = NO_OBJ_SUBDIV; 
    221239 
     240        mSavedViewSpaceSubdivisionType = mViewSpaceSubdivisionType; 
     241        mViewSpaceSubdivisionType = NO_VIEWSPACE_SUBDIV; 
     242 
    222243        // start with view space subdivison: prepare vsp tree for traversal 
    223244        if (StartViewSpaceSubdivision()) 
     
    238259         
    239260        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl; 
     261 
    240262        mHierarchyStats.Stop(); 
    241263        mVspTree->mVspStats.Stop(); 
     264        FinishObjectSpaceSubdivision(); 
     265 
     266        mObjectSpaceSubdivisionType = mSavedObjectSpaceSubdivisionType; 
     267        mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType; 
    242268} 
    243269 
     
    247273                                                                                                   AxisAlignedBox3 *forcedViewSpace) 
    248274{ 
     275        cout << "starting view space hierarchy construction ... " << endl; 
     276 
    249277        RayInfoContainer *viewSpaceRays = new RayInfoContainer(); 
    250278        SubdivisionCandidate *vsc =  
     
    291319                                                                          const ObjectContainer &objects) 
    292320{ 
     321        cout << "starting osp tree construction ... " << endl; 
     322 
    293323        RayInfoContainer *objectSpaceRays = new RayInfoContainer(); 
    294  
    295         cout << "starting osp tree construction ... " << endl; 
    296324 
    297325        // start with one big kd cell - all objects can be seen from everywhere 
     
    342370 
    343371 
     372int HierarchyManager::GetObjectSpaceSubdivisionDepth() const 
     373{ 
     374        int maxDepth = 0; 
     375 
     376        if (mObjectSpaceSubdivisionType == KD_BASED_OBJ_SUBDIV) 
     377        { 
     378                maxDepth = mOspTree->mOspStats.maxDepth; 
     379        } 
     380        else if (mObjectSpaceSubdivisionType == BV_BASED_OBJ_SUBDIV) 
     381        { 
     382                maxDepth = mBvHierarchy->mBvhStats.maxDepth; 
     383        } 
     384 
     385        return maxDepth; 
     386} 
     387 
     388 
    344389bool HierarchyManager::StartObjectSpaceSubdivision() const 
    345390{ 
    346         const bool ospDepthReached =  
    347                 (mMinDepthForObjectSpaceSubdivion <= mVspTree->mVspStats.maxDepth); 
    348      
    349         return !ObjectSpaceSubdivisionConstructed() &&  
    350                    (mTQueue.Empty() || ((mConstructionType == INTERLEAVED) && ospDepthReached)); 
     391        // view space construction already started 
     392        if (ObjectSpaceSubdivisionConstructed()) 
     393                return false; 
     394 
     395        // start immediately with object space subdivision? 
     396        if (mStartWithObjectSpace) 
     397                return true; 
     398 
     399        // is the queue empty again? 
     400        if (ViewSpaceSubdivisionConstructed() && mTQueue.Empty()) 
     401                return true; 
     402 
     403        // has the depth for subdivision been reached? 
     404        return  
     405                ((mConstructionType == INTERLEAVED) &&  
     406                 (mMinDepthForObjectSpaceSubdivion <= mVspTree->mVspStats.maxDepth)); 
    351407} 
    352408 
     
    354410bool HierarchyManager::StartViewSpaceSubdivision() const 
    355411{ 
    356         const bool vspDepthReached =  
    357                 (mMinDepthForObjectSpaceSubdivion <= mVspTree->mVspStats.maxDepth); 
    358      
    359         return !ViewSpaceSubdivisionConstructed() &&  
    360                    (mTQueue.Empty() || ((mConstructionType == INTERLEAVED) && vspDepthReached)); 
     412        // view space construction already started 
     413        if (ViewSpaceSubdivisionConstructed()) 
     414                return false; 
     415 
     416        // start immediately with view space subdivision? 
     417        if (!mStartWithObjectSpace) 
     418                return true; 
     419 
     420        // is the queue empty again? 
     421        if (ObjectSpaceSubdivisionConstructed() && mTQueue.Empty()) 
     422                return true; 
     423 
     424        // has the depth for subdivision been reached? 
     425        return  
     426                ((mConstructionType == INTERLEAVED) &&  
     427                 (mMinDepthForViewSpaceSubdivion <= GetObjectSpaceSubdivisionDepth())); 
    361428} 
    362429 
     
    384451                } 
    385452                 
     453                /////////////////////////// 
    386454                //-- subdivide leaf node 
    387455                if (ApplySubdivisionCandidate(mCurrentCandidate)) 
     
    420488 
    421489                        cout << "starting view space subdivision at depth "  
    422                                  << mVspTree->mVspStats.maxDepth << " ("  
    423                                  << mMinDepthForObjectSpaceSubdivion << ") " << endl; 
     490                                 << GetObjectSpaceSubdivisionDepth() << " ("  
     491                                 << mMinDepthForViewSpaceSubdivion << ") " << endl; 
    424492 
    425493                        PrepareViewSpaceSubdivision(sampleRays, objects, forcedViewSpace); 
     
    432500                DEL_PTR(mCurrentCandidate); 
    433501        } 
    434  
    435         mObjectSpaceSubdivisionType = mSavedObjectSpaceSubdivisionType; 
    436502} 
    437503 
     
    632698                { 
    633699                        BvhLeaf *leaf = mBvHierarchy->GetLeaf(obj); 
    634                         return mBvHierarchy->AddLeafToPvs(leaf, vc, pdf, contribution); 
     700                        BvhIntersectable *bvhObj = mBvHierarchy->GetOrCreateBvhIntersectable(leaf); 
     701                         
     702                        return vc->AddPvsSample(bvhObj, pdf, contribution); 
    635703                } 
    636704        default: 
     
    647715        stream << mVspTree->GetStatistics() << endl; 
    648716        stream << "\nobject space:" << endl << endl; 
     717 
    649718        switch (mObjectSpaceSubdivisionType) 
    650719        { 
     
    726795 
    727796 
    728 } 
     797void HierarchyManager::FinishObjectSpaceSubdivision() const 
     798{ 
     799        switch (mObjectSpaceSubdivisionType) 
     800        { 
     801        case KD_BASED_OBJ_SUBDIV: 
     802                { 
     803                        mOspTree->mOspStats.Stop(); 
     804                        break; 
     805                } 
     806        case BV_BASED_OBJ_SUBDIV: 
     807                { 
     808                        mBvHierarchy->mBvhStats.Stop(); 
     809                        break; 
     810                } 
     811        default: 
     812                break; 
     813        } 
     814} 
     815 
     816} 
  • GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.h

    r1329 r1370  
    166166        }; 
    167167 
     168        enum  
     169        { 
     170                NO_VIEWSPACE_SUBDIV, 
     171                KD_BASED_VIEWSPACE_SUBDIV 
     172        }; 
     173 
    168174        /** The type of object space subdivison 
    169175        */ 
    170         int GetObjectSpaceSubdivisionType() const 
    171         { 
    172                 return mObjectSpaceSubdivisionType; 
    173         } 
    174                  
     176        int GetObjectSpaceSubdivisionType() const;       
     177        /** The type of view space space subdivison 
     178        */ 
     179        int GetViewSpaceSubdivisionType() const; 
     180        /** Sets a pointer to the view cells manager. 
     181        */               
    175182        void SetViewCellsManager(ViewCellsManager *vcm); 
    176  
     183        /** Sets a pointer to the view cells tree. 
     184        */ 
    177185        void SetViewCellsTree(ViewCellsTree *vcTree); 
    178  
     186        /** Exports the object hierarchy to disc. 
     187        */ 
    179188        void ExportObjectSpaceHierarchy(OUT_STREAM &stream); 
    180  
     189        /** Adds a sample to the pvs of the specified view cell. 
     190        */ 
    181191        bool AddSampleToPvs( 
    182192                Intersectable *obj,  
     
    264274    void ResetQueue(); 
    265275 
     276        void FinishObjectSpaceSubdivision() const; 
     277 
     278        int GetObjectSpaceSubdivisionDepth() const; 
    266279 
    267280protected: 
     
    299312 
    300313        int mMinDepthForObjectSpaceSubdivion; 
     314        int mMinDepthForViewSpaceSubdivion; 
    301315 
    302316        int mTermMaxLeaves; 
     
    304318 
    305319        bool mRepairQueue; 
     320 
     321        bool mStartWithObjectSpace; 
    306322}; 
    307323 
  • GTP/trunk/Lib/Vis/Preprocessing/src/VspTree.cpp

    r1315 r1370  
    527527{ 
    528528        const bool localTerminationCriteriaMet = (0 
    529                 //|| ((int)data.mRays->size() <= mTermMinRays) 
    530                 //|| (data.mPvs <= mTermMinPvs) 
    531                 //|| (data.mProbability <= mTermMinProbability) 
    532                 //|| (data.GetAvgRayContribution() > mTermMaxRayContribution) 
    533                 //|| (data.mDepth >= mTermMaxDepth) 
     529                || ((int)data.mRays->size() <= mTermMinRays) 
     530                || (data.mPvs <= mTermMinPvs) 
     531                || (data.mProbability <= mTermMinProbability) 
     532                || (data.GetAvgRayContribution() > mTermMaxRayContribution) 
     533                || (data.mDepth >= mTermMaxDepth) 
    534534                ); 
    535535 
     
    13351335        int bestAxis = -1; 
    13361336 
    1337         // if we use some kind of specialised fixed axis 
     1337        // do we use some kind of specialised "fixed" axis? 
    13381338    const bool useSpecialAxis =  
    13391339                mOnlyDrivingAxis || mCirculatingAxis; 
     
    13691369                        else 
    13701370                        { 
    1371                                 //-- split plane position is spatial median 
     1371                                //-- split plane position is spatial median                              
    13721372                                nPosition[axis] = (box.Min()[axis] + box.Max()[axis]) * 0.5f; 
    13731373                                nCostRatio[axis] = EvalLocalSplitCost(tData, 
     
    13901390        } 
    13911391 
     1392        //////////////////////////////// 
    13921393        //-- assign values of best split 
     1394 
    13931395        plane.mAxis = bestAxis; 
    1394         plane.mPosition = nPosition[bestAxis]; // split plane position 
     1396        // best split plane position 
     1397        plane.mPosition = nPosition[bestAxis]; 
    13951398 
    13961399        pFront = nProbFront[bestAxis]; 
Note: See TracChangeset for help on using the changeset viewer.