Changeset 1698 for GTP/trunk/Lib/Vis


Ignore:
Timestamp:
10/30/06 12:09:35 (18 years ago)
Author:
mattausch
Message:

changed render cost evaluation

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

Legend:

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

    r1696 r1698  
    240240        bool randomize = false; 
    241241        Environment::GetSingleton()->GetBoolValue("VspTree.Construction.randomize", randomize); 
     242          
     243        // initialise random generator for heuristics 
    242244        if (randomize) 
    243                 Randomize(); // initialise random generator for heuristics 
    244  
    245  
    246         //////////////////////////////////// 
     245                Randomize(); 
     246 
     247        ////////////////////////////// 
    247248        //-- termination criteria for autopartition 
    248249 
     
    251252        Environment::GetSingleton()->GetIntValue("BvHierarchy.Termination.minObjects", mTermMinObjects); 
    252253        Environment::GetSingleton()->GetIntValue("BvHierarchy.Termination.minRays", mTermMinRays); 
    253         Environment::GetSingleton()->GetFloatValue("BvHierarchy.Termination.minProbability", mTermMinProbability); 
    254          
    255         Environment::GetSingleton()->GetIntValue("BvHierarchy.Termination.missTolerance", mTermMissTolerance); 
     254        Environment::GetSingleton()->GetFloatValue( 
     255                "BvHierarchy.Termination.minProbability", mTermMinProbability); 
     256    Environment::GetSingleton()->GetIntValue("BvHierarchy.Termination.missTolerance", mTermMissTolerance); 
    256257 
    257258 
     
    282283                "BvHierarchy.Construction.renderCostDecreaseWeight", mRenderCostDecreaseWeight); 
    283284         
    284         Environment::GetSingleton()->GetBoolValue("BvHierarchy.Construction.useGlobalSorting", mUseGlobalSorting); 
     285        Environment::GetSingleton()->GetBoolValue( 
     286                "BvHierarchy.Construction.useGlobalSorting", mUseGlobalSorting); 
     287 
    285288        Environment::GetSingleton()->GetIntValue("BvHierarchy.minRaysForVisibility", mMinRaysForVisibility); 
    286289         
    287  
    288290        mUseBboxAreaForSah = true; 
     291 
    289292 
    290293        ///////////// 
     
    516519        if (computeSplitPlane) 
    517520        { 
    518                 const bool sufficientSamples = splitCandidate.mParentData.mNumRays > mMinRaysForVisibility; 
     521                const bool sufficientSamples =  
     522                        splitCandidate.mParentData.mNumRays > mMinRaysForVisibility; 
    519523 
    520524                const bool useVisibiliyBasedHeuristics =  
    521525                        !mUseSah && 
    522                         (mHierarchyManager->GetViewSpaceSubdivisionType() == HierarchyManager::KD_BASED_VIEWSPACE_SUBDIV) && 
     526                        (mHierarchyManager->GetViewSpaceSubdivisionType() ==  
     527                        HierarchyManager::KD_BASED_VIEWSPACE_SUBDIV) && 
    523528                        sufficientSamples; 
    524529 
     
    531536                // cost ratio violated? 
    532537                const bool maxCostRatioViolated = mTermMaxCostRatio < ratio; 
    533  
    534538                const int previousMisses = splitCandidate.mParentData.mMaxCostMisses; 
    535539 
     
    674678        // objects related stuff 
    675679 
    676         // note: this number should always accumulate to the total number of objects 
     680        // note: the sum should alwaysbe total number of objects for bvh 
    677681        mBvhStats.objectRefs += (int)leaf->mObjects.size(); 
    678682 
     
    813817        // go through the lists, count the number of objects left and right 
    814818        // and evaluate the following cost funcion: 
    815         // C = ct_div_ci  + (ol + or)/queries 
     819        // C = ct_div_ci  + (ol + or) / queries 
    816820        PrepareLocalSubdivisionCandidates(tData, axis); 
    817821 
    818         int objectsLeft = 0, objectsRight = (int)tData.mNode->mObjects.size(); 
     822        const float totalRenderCost = EvalAbsCost(tData.mNode->mObjects); 
     823        float objectsLeft = 0, objectsRight = totalRenderCost; 
    819824   
    820825        const AxisAlignedBox3 nodeBbox = tData.mNode->GetBoundingBox(); 
     
    872877                Intersectable *obj = (*cit).mObject; 
    873878 
    874                 ++ objectsLeft; 
    875                 -- objectsRight; 
     879                const float renderCost = mViewCellsManager->EvalRenderCost(obj); 
     880                //const int renderCost = 1; 
     881 
     882                objectsLeft += renderCost; 
     883                objectsRight -= renderCost; 
    876884 
    877885                const AxisAlignedBox3 obox = obj->GetBox(); 
     
    919927                        areaLeft = al; 
    920928                        areaRight = ar; 
     929 
    921930                        // objects belong to left side now 
    922931                        for (; currentPos != (cit + 1); ++ currentPos); 
     
    936945                objectsFront.push_back((*cit).mObject); 
    937946 
    938         float oldCost = (float)tData.mNode->mObjects.size(); 
    939947        float newCost = minSum / boxArea; 
    940         float ratio = newCost / oldCost; 
     948        float ratio = newCost / totalRenderCost; 
    941949   
    942950#ifdef _DEBUG 
     
    10011009                                                                                   ObjectContainer &objectsBack) 
    10021010{ 
    1003         //////////////////////////////////////////////////////////////// 
    1004         // go through the lists, count the number of objects left and right 
    1005         // and evaluate the cost funcion 
     1011        /////////////////////////////////////////////////////// 
     1012        // -- go through the lists, count the number of objects left  
     1013        //-- and right and evaluate the cost funcion 
    10061014 
    10071015        // prepare the heuristics by setting mailboxes and counters. 
     
    10111019        float volLeft = 0; 
    10121020        float volRight = totalVol; 
    1013         int nObjectsLeft = 0; 
    1014         const int nTotalObjects = (int)tData.mNode->mObjects.size(); 
     1021         
     1022        const float nTotalObjects = EvalAbsCost(tData.mNode->mObjects); 
     1023        float nObjectsLeft = 0; 
     1024        float nObjectsRight = nTotalObjects; 
     1025 
    10151026        const float viewSpaceVol = mViewCellsManager->GetViewSpaceBox().GetVolume(); 
    10161027 
     
    10381049        //-- traverse through events and find best split plane 
    10391050 
    1040         SortableEntryContainer::const_iterator cit, cit_end = cit_end = mSubdivisionCandidates->end(); 
     1051        SortableEntryContainer::const_iterator cit,  
     1052                cit_end = cit_end = mSubdivisionCandidates->end(); 
    10411053 
    10421054        for (cit = mSubdivisionCandidates->begin(); cit != cit_end; ++ cit) 
     
    10491061                EvalHeuristicsContribution(object, volLeft, volRight); 
    10501062 
    1051                 ++ nObjectsLeft; 
    1052                 const int nObjectsRight = nTotalObjects - nObjectsLeft; 
    1053  
     1063                const float rc = mViewCellsManager->EvalRenderCost(object); 
     1064 
     1065                nObjectsLeft += rc; 
     1066                nObjectsRight -= rc; 
     1067                 
    10541068                // the heuristics 
    10551069            const float sum = volLeft * (float)nObjectsLeft +  
     
    14051419 
    14061420 
     1421float BvHierarchy::EvalAbsCost(const ObjectContainer &objects) const 
     1422{ 
     1423#if USE_BETTER_RENDERCOST_EST 
     1424        ObjectContainer::const_iterator oit, oit_end = objects.end(); 
     1425 
     1426        for (oit = objects.begin(); oit != oit_end; ++ oit) 
     1427        { 
     1428                objRenderCost += mViewCellsManager->GetRendercost(*oit); 
     1429        } 
     1430#else 
     1431        return (float)objects.size(); 
     1432#endif 
     1433} 
     1434 
     1435 
    14071436float BvHierarchy::EvalRenderCost(const ObjectContainer &objects) const 
    14081437{        
    1409         if (0 &&  
    1410                 (mHierarchyManager->GetViewSpaceSubdivisionType() ==  
    1411                 HierarchyManager::NO_VIEWSPACE_SUBDIV)) 
    1412         { 
    1413                 //////////////// 
    1414                 //-- surface area heuristics 
    1415  
    1416                 if (objects.empty()) 
    1417                         return 0.0f; 
    1418  
    1419                 const AxisAlignedBox3 box = EvalBoundingBox(objects); 
    1420                 const float area = box.SurfaceArea(); 
    1421                 const float viewSpaceArea = mViewCellsManager->GetViewSpaceBox().SurfaceArea(); 
    1422  
    1423                 return (float)objects.size() * area / viewSpaceArea; 
    1424         } 
    1425         else 
    1426         {       /////////////// 
    1427                 //-- render cost heuristics 
    1428  
    1429                 const float viewSpaceVol = mViewCellsManager->GetViewSpaceBox().GetVolume(); 
    1430  
    1431                 // probability that view point lies in a view cell which sees this node 
    1432                 const float p = EvalViewCellsVolume(objects) / viewSpaceVol;     
    1433  
    1434                 return (float)objects.size() * p; 
    1435         } 
     1438        /////////////// 
     1439        //-- render cost heuristics 
     1440 
     1441        const float viewSpaceVol = mViewCellsManager->GetViewSpaceBox().GetVolume(); 
     1442 
     1443        // probability that view point lies in a view cell which sees this node 
     1444        const float p = EvalViewCellsVolume(objects) / viewSpaceVol; 
     1445    float objRenderCost = EvalAbsCost(objects); 
     1446         
     1447        return objRenderCost * p; 
    14361448} 
    14371449 
     
    15901602int BvHierarchy::CountViewCells(const ObjectContainer &objects) const 
    15911603{ 
    1592         // no view cells yet 
    1593         if (0 && mHierarchyManager->GetViewSpaceSubdivisionType() ==  
    1594                 HierarchyManager::NO_VIEWSPACE_SUBDIV) 
    1595                 return 1; 
    1596  
    15971604        int nViewCells = 0; 
    1598  
    15991605        ViewCell::NewMail(); 
    1600  
    16011606        ObjectContainer::const_iterator oit, oit_end = objects.end(); 
    16021607 
     
    17281733{ 
    17291734        // search nodes 
    1730         std::map<BvhNode *, BvhIntersectable *>::const_iterator it  
    1731                 = mBvhIntersectables.find(node); 
     1735        std::map<BvhNode *, BvhIntersectable *>::const_iterator  
     1736                it = mBvhIntersectables.find(node); 
    17321737 
    17331738        if (it != mBvhIntersectables.end())  
     
    18161821void BvHierarchy::Initialise(const ObjectContainer &objects) 
    18171822{ 
     1823        AxisAlignedBox3 box = EvalBoundingBox(objects); 
     1824 
    18181825        /////// 
    18191826        //-- create new root 
    18201827 
    1821         AxisAlignedBox3 box = EvalBoundingBox(objects); 
    18221828        BvhLeaf *bvhleaf = new BvhLeaf(box, NULL, (int)objects.size()); 
    18231829        bvhleaf->mObjects = objects; 
     
    18341840/* 
    18351841Mesh *BvHierarchy::MergeLeafToMesh() 
    1836 void BvHierarchy::MergeLeavesToMeshes() 
    18371842{ 
    18381843        vector<BvhLeaf *> leaves; 
     
    19031908        bvhLeaf->SetSubdivisionCandidate(oSubdivisionCandidate); 
    19041909 
    1905         const float viewSpaceVol = mViewCellsManager->GetViewSpaceBox().GetVolume(); 
    1906         mTotalCost = (float)objects.size() * prop / viewSpaceVol; 
     1910        mTotalCost = EvalRenderCost(objects); 
    19071911        mPvsEntries = CountViewCells(objects); 
    19081912 
  • GTP/trunk/Lib/Vis/Preprocessing/src/BvHierarchy.h

    r1695 r1698  
    609609        ///////////////////////////////// 
    610610 
     611        float EvalAbsCost(const ObjectContainer &objects) const; 
     612 
    611613protected: 
    612614 
  • GTP/trunk/Lib/Vis/Preprocessing/src/VspTree.cpp

    r1696 r1698  
    16381638        if (!obj) return; 
    16391639 
    1640         //const float renderCost = mViewCellsManager->SimpleRay &raynderCost(obj); 
    1641         const int renderCost = 1; 
     1640        const float renderCost = mViewCellsManager->EvalRenderCost(obj); 
    16421641 
    16431642        // object in no pvs => new 
     
    16501649        // the object belongs to no pvs in this case? 
    16511650        //if (cf == Ray::COINCIDENT) return; 
    1652  
    16531651        if (cf >= 0) // front pvs 
    16541652        { 
     
    16891687{ 
    16901688        if (!leaf) return; 
    1691         const int renderCost = countEntries ? 1 : (int)leaf->mObjects.size(); 
     1689 
     1690        const float renderCost = countEntries ? 1 :  
     1691                mHierarchyManager->mBvHierarchy->EvalAbsCost(leaf->mObjects); 
    16921692         
    16931693        // leaf in no pvs => new 
     
    17271727        } 
    17281728} 
    1729  
    17301729 
    17311730 
     
    18011800                        // test if this leaf is in valid view space 
    18021801                        VspLeaf *leaf = dynamic_cast<VspLeaf *>(node); 
     1802 
    18031803                        if (leaf->TreeValid() &&  
    18041804                                (!onlyUnmailed || !leaf->Mailed()) && 
Note: See TracChangeset for help on using the changeset viewer.