Changeset 1912


Ignore:
Timestamp:
12/20/06 00:26:02 (17 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/Lib/Vis/Preprocessing/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r1911 r1912  
    381381        const BvhTraversalData &tData = sc.mParentData; 
    382382        BvhLeaf *leaf = tData.mNode; 
     383 
    383384        AxisAlignedBox3 parentBox = leaf->GetBoundingBox(); 
    384385 
    … …  
    424425 
    425426        //////////////////////////////////////// 
    426         //-- fill  front and back traversal data with the new values 
     427        //-- fill front and back traversal data with the new values 
    427428 
    428429        frontData.mDepth = backData.mDepth = tData.mDepth + 1; 
    … …  
    442443        AssociateObjectsWithLeaf(front); 
    443444    
    444 #if PROBABILIY_IS_BV_VOLUME 
    445         // volume of bvh (= probability that this bvh can be seen) 
    446         frontData.mProbability = fbox.GetVolume(); 
    447         backData.mProbability = bbox.GetVolume(); 
    448 #else 
     445        //-- compute pvs correction to cope with undersampling 
     446        frontData.mPvs = CountViewCells(front->mObjects); 
     447        backData.mPvs = CountViewCells(back->mObjects); 
     448 
     449        frontData.mCorrectedPvs = sc.mCorrectedFrontPvs; 
     450        backData.mCorrectedPvs = sc.mCorrectedBackPvs; 
     451 
    449452        // compute probability of this node being visible,  
    450453        // i.e., volume of the view cells that can see this node 
    451         frontData.mProbability = EvalViewCellsVolume(sc.mFrontObjects); 
    452         backData.mProbability = EvalViewCellsVolume(sc.mBackObjects); 
    453 #endif 
     454        frontData.mRenderCost = EvalRenderCost(sc.mFrontObjects); 
     455        backData.mRenderCost = EvalRenderCost(sc.mBackObjects); 
     456 
     457        frontData.mCorrectedRenderCost = sc.mCorrectedFrontCost; 
     458        backData.mCorrectedRenderCost = sc.mCorrectedBackCost; 
    454459 
    455460    // how often was max cost ratio missed in this branch? 
    456461        frontData.mMaxCostMisses = sc.GetMaxCostMisses(); 
    457462        backData.mMaxCostMisses = sc.GetMaxCostMisses(); 
    458          
     463 
    459464        // set the time stamp so the order of traversal can be reconstructed 
    460465        node->SetTimeStamp(mHierarchyManager->mTimeStamp ++); 
    … …  
    619624        } 
    620625 
    621         BvhLeaf *leaf = splitCandidate.mParentData.mNode; 
    622  
    623         if (USE_AVGRAYCONTRI) 
    624         { 
    625                 // this leaf is a pvs entry in all the view cells 
    626                 // that see one of the objects. 
    627                 const int pvs = CountViewCells(leaf->mObjects); 
    628                 //const int pvs = (int)leaf->mObjects.size(); 
    629          
    630                 // avg contribution of a ray to a pvs 
    631                 const float avgRayContri =  
    632                         AvgRayContribution(pvs, splitCandidate.mParentData.mNumRays); 
    633  
    634                 // high avg ray contri, the result is influenced by undersampling 
    635                 splitCandidate.SetAvgRayContri(avgRayContri); 
    636         } 
    637  
    638         const float oldProp = EvalViewCellsVolume(leaf->mObjects); 
     626        const BvhTraversalData &tData = splitCandidate.mParentData; 
     627        BvhLeaf *leaf = tData.mNode; 
     628 
     629        // avg contribution of a ray to a pvs 
     630        const float pvs = CountViewCells(leaf->mObjects); 
     631        const float avgRayContri = AvgRayContribution(pvs, tData.mNumRays); 
     632 
     633        cout << "bvh avg ray contri: " << avgRayContri << endl; 
     634        // high avg ray contri, the result is influenced by undersampling 
     635        splitCandidate.SetAvgRayContribution(avgRayContri); 
     636 
    639637        const float oldRenderCost = EvalRenderCost(leaf->mObjects); 
     638        const float oldRatio = oldRenderCost / tData.mRenderCost; 
     639        const float parentCost = tData.mCorrectedRenderCost * oldRatio; 
     640 
     641        cout << "old ratio: " << oldRatio << endl; 
     642        // this leaf is a pvs entry in all the view cells 
     643        // that see one of the objects. 
     644        const int frontCost = EvalRenderCost(splitCandidate.mFrontObjects); 
     645        const int backCost = EvalRenderCost(splitCandidate.mBackObjects); 
     646 
     647        cout <<"here8 ============ "<< parentCost << endl; 
     648        splitCandidate.mCorrectedFrontCost =  
     649                mHierarchyManager->EvalCorrectedPvs(frontCost, parentCost, avgRayContri); 
     650 
     651        cout << "bvh front cost: " << frontCost << " corrected: " << splitCandidate.mCorrectedFrontCost << endl; 
     652        cout <<"here104 "<< endl; 
     653 
     654        splitCandidate.mCorrectedBackCost =  
     655                mHierarchyManager->EvalCorrectedPvs(backCost, parentCost, avgRayContri); 
     656         
     657        cout << "back cost: " << backCost << " corrected: " << splitCandidate.mCorrectedBackCost << endl; 
    640658 
    641659        // compute global decrease in render cost 
    642         const float newRenderCost = EvalRenderCost(splitCandidate.mFrontObjects) + 
    643                                                                 EvalRenderCost(splitCandidate.mBackObjects); 
    644  
    645         const float renderCostDecr = oldRenderCost - newRenderCost; 
     660        const float newRenderCost =  
     661                splitCandidate.mCorrectedFrontCost + splitCandidate.mCorrectedBackCost; 
     662        const float renderCostDecr = parentCost - newRenderCost; 
    646663         
    647664        splitCandidate.SetRenderCostDecrease(renderCostDecr); 
    648665 
    649666        // increase in pvs entries 
    650         const int pvsEntriesIncr = EvalPvsEntriesIncr(splitCandidate); 
     667        const int pvsEntriesIncr = EvalPvsEntriesIncr(splitCandidate, avgRayContri); 
    651668        splitCandidate.SetPvsEntriesIncr(pvsEntriesIncr); 
    652669         
    … …  
    666683 
    667684 
    668 int BvHierarchy::EvalPvsEntriesIncr(BvhSubdivisionCandidate &splitCandidate) const 
     685int BvHierarchy::EvalPvsEntriesIncr(BvhSubdivisionCandidate &splitCandidate,  
     686                                                                        const float avgRayContri) const 
    669687{ 
    670688        const int oldPvsSize = CountViewCells(splitCandidate.mParentData.mNode->mObjects); 
    671          
    672         const int fPvsSize = CountViewCells(splitCandidate.mFrontObjects); 
    673         const int bPvsSize = CountViewCells(splitCandidate.mBackObjects); 
    674  
    675         return fPvsSize + bPvsSize - oldPvsSize; 
     689        const float oldPvsRatio = splitCandidate.mParentData.mPvs > 0 ? oldPvsSize / splitCandidate.mParentData.mPvs : 1; 
     690 
     691        const float parentPvs = splitCandidate.mParentData.mCorrectedPvs * oldPvsRatio; 
     692 
     693        const int frontViewCells = CountViewCells(splitCandidate.mFrontObjects); 
     694        const int backViewCells = CountViewCells(splitCandidate.mBackObjects); 
     695         
     696        cout <<"here105 " << splitCandidate.mParentData.mCorrectedPvs << endl; 
     697        cout <<"here106 " << oldPvsRatio << endl; 
     698 
     699        splitCandidate.mCorrectedFrontPvs =  
     700                mHierarchyManager->EvalCorrectedPvs(frontViewCells, parentPvs, avgRayContri); 
     701        splitCandidate.mCorrectedBackPvs = 
     702                mHierarchyManager->EvalCorrectedPvs(backViewCells, parentPvs, avgRayContri); 
     703 
     704        return splitCandidate.mCorrectedFrontPvs + splitCandidate.mCorrectedBackPvs - parentPvs; 
    676705} 
    677706 
    … …  
    730759 
    731760         
    732         if (data.mProbability <= mTermMinProbability) 
     761        /*if (data.mProbability <= mTermMinProbability) 
    733762        { 
    734763                ++ mBvhStats.minProbabilityNodes; 
    735         } 
     764        }*/ 
    736765 
    737766        //////////////////////////////////////////// 
    … …  
    21672196        // create bvh traversal data 
    21682197        BvhTraversalData oData(bvhLeaf, 0, prop, nRays); 
    2169  
     2198         
    21702199        // create sorted object lists for the first data 
    21712200        if (mUseGlobalSorting) 
    … …  
    21782207        //-- add first candidate for object space partition      
    21792208 
     2209        mTotalCost = EvalRenderCost(objects); 
     2210        mPvsEntries = CountViewCells(objects); 
     2211 
     2212        oData.mCorrectedPvs = oData.mPvs = mPvsEntries; 
     2213        oData.mCorrectedRenderCost = oData.mRenderCost = mTotalCost; 
     2214        cout << "here52 " << oData.mCorrectedPvs << " " << oData.mRenderCost << " " << oData.mCorrectedRenderCost << endl; 
     2215 
     2216 
    21802217        BvhSubdivisionCandidate *oSubdivisionCandidate =  
    21812218                new BvhSubdivisionCandidate(oData); 
    21822219 
    21832220        bvhLeaf->SetSubdivisionCandidate(oSubdivisionCandidate); 
    2184  
    2185         mTotalCost = EvalRenderCost(objects); 
    2186         mPvsEntries = CountViewCells(objects); 
    21872221 
    21882222        if (mApplyInitialPartition) 

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

    r1903 r1912  
    382382                mNode(NULL), 
    383383                mDepth(0), 
    384                 mProbability(0.0), 
    385384                mMaxCostMisses(0),  
    386385                mAxis(0), 
    387                 mNumRays(0) 
     386                mNumRays(0), 
     387                mCorrectedPvs(0), 
     388                mPvs(0), 
     389                mCorrectedRenderCost(0), 
     390                mRenderCost(0) 
    388391                { 
    389392                        for (int i = 0; i < 4; ++ i) 
    … …  
    397400                mNode(node),  
    398401                mDepth(depth), 
    399                 //mBoundingBox(box), 
    400                 mProbability(v), 
    401402                mMaxCostMisses(0), 
    402403                mAxis(0), 
    403                 mNumRays(numRays) 
     404                mNumRays(numRays), 
     405                mCorrectedPvs(0), 
     406                mPvs(0), 
     407                mCorrectedRenderCost(0), 
     408                mRenderCost(v) 
    404409                { 
    405410                        for (int i = 0; i < 4; ++ i) 
    … …  
    420425                /// current depth 
    421426                int mDepth; 
    422                 /// the probability that this node is seen 
    423                 float mProbability; 
    424                 /// the bounding box of the node 
    425                 //AxisAlignedBox3 mBoundingBox; 
     427                /// the render cost of the node 
     428                float mRenderCost; 
     429                /// the corrected render cost; 
     430                float mCorrectedRenderCost; 
    426431                /// how often this branch has missed the max-cost ratio 
    427432                int mMaxCostMisses; 
    … …  
    430435                /// number of rays 
    431436                int mNumRays; 
     437                /// parent Pvs; 
     438                float mPvs; 
     439                /// parent pvs correction factor 
     440                float mCorrectedPvs; 
     441 
    432442                /// the sorted objects for the three dimensions 
    433443                ObjectContainer *mSortedObjects[4];              
    … …  
    486496                        return mPriority; 
    487497                } 
     498 
     499                /////////////////////////////7 
    488500 
    489501                /// pointer to parent tree. 
    … …  
    496508                /// the objects on the back of the potential split 
    497509                ObjectContainer mBackObjects; 
     510                         
     511                float mCorrectedFrontPvs; 
     512                float mCorrectedBackPvs; 
     513 
     514                float mCorrectedFrontCost; 
     515                float mCorrectedBackCost; 
    498516        }; 
    499517 
    … …  
    821839        /** Evaluates increase in pvs size. 
    822840        */ 
    823         int EvalPvsEntriesIncr(BvhSubdivisionCandidate &splitCandidate) const; 
     841        int EvalPvsEntriesIncr(BvhSubdivisionCandidate &splitCandidate, const float avgRayContri) const; 
    824842 
    825843        /** Rays will be clipped to the bounding box. 

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

    r1902 r1912  
    26582658                                        "99999.0"); 
    26592659         
     2660        RegisterOption("Hierarchy.Construction.minAvgRayContri", 
     2661                                        optFloat, 
     2662                                        "hierarchy_construction_min_avg_raycontri=", 
     2663                                        "99990.0"); 
     2664         
    26602665        ///////////////////////////////////////////////////////////////// 
    26612666 

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

    r1911 r1912  
    156156                "Hierarchy.Construction.maxAvgRayContri", mMaxAvgRayContri); 
    157157 
     158        Environment::GetSingleton()->GetFloatValue( 
     159                "Hierarchy.Construction.minAvgRayContri", mMinAvgRayContri); 
     160 
    158161        // for comparing it with byte - value 
    159162        mTermMaxMemory *= (1024.0f * 1024.0f); 
    … …  
    734737 
    735738 
    736 float HierarchyManager::EvalPvsCorrectionFactor(const float childPvs,  
    737                                                                                                 const float totalPvs,  
    738                                                                                                 const float avgRayContri) const 
    739 { 
    740         if (!childPvs || 
    741                 // assume pvs sampled sufficiently => take child pvs 
    742                 (avgRayContri < mMinAvgRayContri)) 
    743                 return 1.0f; 
     739float HierarchyManager::EvalCorrectedPvs(const float childPvs,  
     740                                                                                 const float totalPvs,  
     741                                                                                 const float avgRayContri) const 
     742{ 
     743        // assume pvs sampled sufficiently => take child pvs 
     744        if (avgRayContri < mMinAvgRayContri) 
     745                return childPvs; 
    744746 
    745747        // assume pvs not sampled sufficiently => take total pvs 
    746748        if (avgRayContri > mMaxAvgRayContri) 
    747                 return totalPvs / childPvs; 
    748  
    749         const float factor =  
    750                         (mMaxAvgRayContri - avgRayContri) /  
    751                         (mMaxAvgRayContri - mMinAvgRayContri); 
    752  
    753         const float newPvs = factor * childPvs + (1.0f - factor) * totalPvs;     
    754          
    755         return newPvs / childPvs; 
     749                return totalPvs; 
     750 
     751        const float alpha = (mMaxAvgRayContri - avgRayContri) /  
     752                                                (mMaxAvgRayContri - mMinAvgRayContri); 
     753 
     754        cout << "here41 **************** " << alpha << " " << childPvs << " " << totalPvs << endl; 
     755 
     756        const float beta = (1.0f - alpha) * (totalPvs + childPvs) / totalPvs; 
     757 
     758        return childPvs + beta; 
    756759} 
    757760 

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

    r1911 r1912  
    296296        void CreateUniqueObjectIds(); 
    297297 
    298         float EvalPvsCorrectionFactor(const float pvsFront,  
    299                                                                   const float totalPvs, 
    300                                                                   const float avgRayContri) const; 
     298        float EvalCorrectedPvs(const float pvsFront,  
     299                                                   const float totalPvs, 
     300                                                   const float avgRayContri) const; 
    301301 
    302302 

  • GTP/trunk/Lib/Vis/Preprocessing/src/TestPreprocessor.vcproj

    r1845 r1912  
    206206                                Name="VCLinkerTool" 
    207207                                AdditionalDependencies="xerces-c_2.lib glew32.lib zdll.lib zziplib.lib devil.lib glut32.lib OpenGL32.Lib glu32.lib Preprocessor.lib RTScene.lib RTWorld.lib QtCore4.lib qtmain.lib QtOpenGL4.lib Qt3Support4.lib QtTest4.lib QtGui4.lib QtGlRenderer.lib" 
    208                                 OutputFile="../bin/release/Preprocessor.exe" 
     208                                OutputFile="../bin/release/Preprocessor2.exe" 
    209209                                LinkIncremental="1" 
    210210                                AdditionalLibraryDirectories="..\src\GL;..\lib\release;..\..\Preprocessing\lib\release;..\..\..\..\..\..\NonGTP\Boost\lib;..\..\..\..\..\..\NonGTP\Xerces\xercesc\lib;..\..\..\..\..\..\NonGTP\Zlib\lib;..\..\..\..\..\..\NonGTP\Devil\lib;..\MultiLevelRayTracing\RTScene\Release;..\MultiLevelRayTracing\RTWorld\Release;&quot;$(QTDIR)\lib&quot;;.\QtGlRenderer\Release" 

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

    r1911 r1912  
    724724                 
    725725                // create new interior node and two leaf node 
    726                 const AxisAlignedPlane splitPlane = sc->mSplitPlane; 
    727726                const int maxCostMisses = sc->GetMaxCostMisses(); 
    728727 
    729                 newNode = SubdivideNode(splitPlane, tData, tFrontData, tBackData); 
     728                newNode = SubdivideNode(*sc, 
     729                                                                tFrontData,  
     730                                                                tBackData); 
    730731         
    731732                // how often was max cost ratio missed in this branch? 
    … …  
    832833         
    833834        VspLeaf *leaf = dynamic_cast<VspLeaf *>(splitCandidate.mParentData.mNode); 
    834          
     835 
     836        ///////////// 
     837        // avg ray contri 
     838 
     839        const int pvs = EvalPvsEntriesSize(*splitCandidate.mParentData.mRays); 
     840 
     841        const float avgRayContri = (float)pvs /  
     842                ((float)splitCandidate.mParentData.mRays->size() + Limits::Small); 
     843 
     844        splitCandidate.SetAvgRayContribution(avgRayContri); 
     845        cout << "vsp avg ray contri: " << avgRayContri << endl; 
     846 
    835847        // compute global decrease in render cost 
    836848        float oldRenderCost; 
    837         const float renderCostDecr = EvalRenderCostDecrease(splitCandidate.mSplitPlane,  
    838                                                                                                                 splitCandidate.mParentData, 
    839                                                                                                                 oldRenderCost); 
    840  
     849        const float renderCostDecr = EvalRenderCostDecrease(splitCandidate, oldRenderCost); 
    841850        splitCandidate.SetRenderCostDecrease(renderCostDecr); 
    842851 
    … …  
    854863        { 
    855864                priority /= ((float)splitCandidate.GetPvsEntriesIncr() + mMemoryConst); 
    856         } 
    857  
    858  
    859         ///////////// 
    860         // avg ray contri 
    861  
    862         if (USE_AVGRAYCONTRI) 
    863         { 
    864                 const int pvs = EvalPvsEntriesSize(*splitCandidate.mParentData.mRays); 
    865  
    866                 const float avgRayContri = (float)pvs /  
    867                         ((float)splitCandidate.mParentData.mRays->size() + Limits::Small); 
    868  
    869                 splitCandidate.SetAvgRayContribution(avgRayContri); 
    870865        } 
    871866 
    … …  
    904899        } 
    905900 
    906         return (int)(fPvsSize + bPvsSize - oldPvsSize); 
    907 } 
    908  
    909  
    910 VspInterior *VspTree::SubdivideNode(const AxisAlignedPlane &splitPlane, 
    911                                                                         VspTraversalData &tData, 
     901        const float oldPvsRatio = oldPvsSize / splitCandidate.mParentData.mPvs; 
     902        const float correctedOldPvs = splitCandidate.mParentData.mCorrectedPvs * oldPvsRatio; 
     903 
     904        cout <<"here102 "<< endl; 
     905        cout << "old pvs ratio: " << oldPvsRatio << endl; 
     906        const float correctedFrontPvs =  
     907                mHierarchyManager->EvalCorrectedPvs(fPvsSize,  
     908                                                                                        correctedOldPvs,  
     909                                                                                        splitCandidate.GetAvgRayContribution()); 
     910        cout <<"here103 "<< endl; 
     911        const float correctedBackPvs =  
     912                mHierarchyManager->EvalCorrectedPvs(bPvsSize,  
     913                                                                                        correctedOldPvs,  
     914                                                                                        splitCandidate.GetAvgRayContribution()); 
     915 
     916         
     917        cout << "vsp front entries " << fPvsSize << " corrected: " << correctedFrontPvs << endl; 
     918        cout << "vsp back entries " << bPvsSize << " corrected: " << correctedBackPvs << endl; 
     919 
     920        return (int)(correctedFrontPvs + correctedBackPvs - correctedOldPvs); 
     921} 
     922 
     923 
     924VspInterior *VspTree::SubdivideNode(const VspSubdivisionCandidate &sc, 
    912925                                                                        VspTraversalData &frontData, 
    913926                                                                        VspTraversalData &backData) 
    914927{ 
    915         VspLeaf *leaf = dynamic_cast<VspLeaf *>(tData.mNode); 
    916          
     928        VspLeaf *leaf = dynamic_cast<VspLeaf *>(sc.mParentData.mNode); 
     929 
     930        const VspTraversalData &tData = sc.mParentData; 
     931        const AxisAlignedPlane splitPlane = sc.mSplitPlane; 
     932 
    917933        /////////////// 
    918934        //-- new traversal values 
    … …  
    928944 
    929945        //-- compute pvs 
    930         frontData.mPvs = EvalPvsCost(*frontData.mRays); 
    931         backData.mPvs = EvalPvsCost(*backData.mRays); 
    932                  
     946        frontData.mPvs = (float)EvalPvsEntriesSize(*frontData.mRays); 
     947        backData.mPvs = (float)EvalPvsEntriesSize(*backData.mRays); 
     948         
     949        //-- compute pvs correction for coping with undersampling 
     950        frontData.mCorrectedPvs = sc.mCorrectedFrontPvs; 
     951        backData.mCorrectedPvs = sc.mCorrectedBackPvs; 
     952 
    933953        //-- split front and back node geometry and compute area 
    934954        tData.mBoundingBox.Split(splitPlane.mAxis,  
    … …  
    940960        backData.mProbability = tData.mProbability - frontData.mProbability; 
    941961 
     962        //-- compute render cost 
     963        frontData.mRenderCost = (float)EvalRenderCost(*frontData.mRays); 
     964        backData.mRenderCost = (float)EvalRenderCost(*backData.mRays); 
     965         
     966        frontData.mCorrectedRenderCost = sc.mCorrectedFrontPvs; 
     967        backData.mCorrectedRenderCost = sc.mCorrectedBackPvs; 
    942968 
    943969        //////// 
    … …  
    15191545 
    15201546 
    1521 float VspTree::EvalRenderCostDecrease(const AxisAlignedPlane &candidatePlane, 
    1522                                                                           const VspTraversalData &tData, 
    1523                                                                           float &normalizedOldRenderCost, 
    1524                                                                           const float avgRayContri) const 
     1547float VspTree::EvalRenderCostDecrease(VspSubdivisionCandidate &sc, 
     1548                                                                          float &normalizedOldRenderCost) const 
    15251549{ 
    15261550        float pvsFront = 0; 
    … …  
    15291553 
    15301554        const float viewSpaceVol = mBoundingBox.GetVolume(); 
     1555        const VspTraversalData &tData = sc.mParentData; 
     1556         
     1557        const AxisAlignedPlane &candidatePlane = sc.mSplitPlane; 
     1558        const float avgRayContri = sc.GetAvgRayContribution(); 
    15311559 
    15321560        ////////////////////////////////////////////// 
    … …  
    15371565        KdLeaf::NewMail(3); 
    15381566 
    1539         RayInfoContainer::const_iterator rit, rit_end = data.mRays->end(); 
    1540  
    1541         for (rit = data.mRays->begin(); rit != rit_end; ++ rit) 
     1567        RayInfoContainer::const_iterator rit, rit_end = tData.mRays->end(); 
     1568 
     1569        for (rit = tData.mRays->begin(); rit != rit_end; ++ rit) 
    15421570        { 
    15431571                RayInfo rayInf = *rit; 
    … …  
    15631591        AxisAlignedBox3 backBox; 
    15641592 
    1565         data.mBoundingBox.Split(candidatePlane.mAxis,  
    1566                                                         candidatePlane.mPosition,  
    1567                                                         frontBox,  
    1568                                                         backBox); 
    1569  
    1570         // probability that view point lies in back / front node 
    1571         float pOverall = data.mProbability; 
     1593        tData.mBoundingBox.Split(candidatePlane.mAxis,  
     1594                                                         candidatePlane.mPosition,  
     1595                                                         frontBox,  
     1596                                                         backBox); 
     1597 
     1598    // probability that view point lies in back / front node 
     1599        float pOverall = tData.mProbability; 
    15721600        float pFront = frontBox.GetVolume(); 
    15731601        float pBack = pOverall - pFront; 
    … …  
    15761604        /////////////////// 
    15771605        //-- evaluate render cost heuristics 
    1578 #if 0 
    1579         const float penaltyOld = totalPvs; 
    1580  
    1581     const float penaltyFront = pvsFront; 
    1582         const float penaltyBack = pvsBack; 
    1583 #else 
    1584         const float penaltyOld = totalPvs * tData.mPvsCorrectionFactor; 
    1585  
    1586         const float frontCorr = mHierarchyManager->EvalPvsCorrectionFactor(pvsFront, penaltyOld, avgRayContri); 
    1587         const float backCorr = mHierarchyManager->EvalPvsCorrectionFactor(pvsBack, penaltyOld, avgRayContri); 
    1588  
    1589         const float penaltyFront = frontCorr; 
    1590         const float penaltyBack = pvsBack * backCorr;; 
    1591 #endif 
     1606 
     1607        const float oldRenderCostRatio = tData.mPvs ? (totalPvs / tData.mPvs) : 1; 
     1608 
     1609        const float penaltyOld = tData.mCorrectedPvs * oldRenderCostRatio; 
     1610 
     1611        cout <<"here107 " << penaltyOld << endl; 
     1612        sc.mCorrectedFrontPvs = mHierarchyManager->EvalCorrectedPvs(pvsFront, penaltyOld, avgRayContri); 
     1613        cout <<"here108 " << tData.mCorrectedPvs << " " << oldRenderCostRatio << endl; 
     1614        sc.mCorrectedBackPvs = mHierarchyManager->EvalCorrectedPvs(pvsBack, penaltyOld, avgRayContri); 
     1615 
     1616        cout << "vsp front pvs " << pvsFront << " corrected: " << sc.mCorrectedFrontPvs << endl; 
     1617        cout << "vsp back pvs " << pvsBack << " corrected: " << sc.mCorrectedBackPvs << endl; 
    15921618 
    15931619        const float oldRenderCost = pOverall * penaltyOld; 
    1594         const float newRenderCost = penaltyFront * pFront + penaltyBack * pBack; 
     1620        const float newRenderCost = sc.mCorrectedFrontPvs * pFront + sc.mCorrectedBackPvs * pBack; 
    15951621 
    15961622        // we also return the old render cost 
    … …  
    16121638 
    16131639 
    1614 float VspTree::EvalLocalSplitCost(const VspTraversalData &data, 
     1640float VspTree::EvalLocalSplitCost(const VspTraversalData &tData, 
    16151641                                                                  const AxisAlignedBox3 &box, 
    16161642                                                                  const int axis, 
    … …  
    16271653        KdLeaf::NewMail(3); 
    16281654 
    1629         const float pvsSize = data.mPvs; 
    1630         RayInfoContainer::const_iterator rit, rit_end = data.mRays->end(); 
     1655        RayInfoContainer::const_iterator rit, rit_end = tData.mRays->end(); 
    16311656 
    16321657        // this is the main ray classification loop! 
    1633         for(rit = data.mRays->begin(); rit != rit_end; ++ rit) 
     1658        for(rit = tData.mRays->begin(); rit != rit_end; ++ rit) 
    16341659        { 
    16351660                VssRay *ray = (*rit).mRay; 
    … …  
    16451670        ////////////// 
    16461671        //-- evaluate cost heuristics 
    1647         float pOverall = data.mProbability; 
     1672 
     1673        float pOverall = tData.mProbability; 
    16481674 
    16491675        // we use spatial mid split => simplified computation 
    … …  
    16511677         
    16521678        const float newCost = pvsBack * pBack + pvsFront * pFront; 
    1653         const float oldCost = (float)pvsSize * pOverall + Limits::Small; 
     1679        const float oldCost = (float)pvsTotal * pOverall + Limits::Small; 
    16541680         
    16551681#ifdef GTPGTP_DEBUG 
    … …  
    29212947#endif 
    29222948 
     2949        mTotalCost = vData.mCorrectedPvs = pvsCost; 
     2950        mPvsEntries = EvalPvsEntriesSize(rays); 
     2951 
    29232952        ////////////// 
    29242953        //-- create the first split candidate 
    … …  
    29272956    EvalSubdivisionCandidate(*splitCandidate); 
    29282957        leaf->SetSubdivisionCandidate(splitCandidate); 
    2929  
    2930         mTotalCost = pvsCost; 
    2931         mPvsEntries = EvalPvsEntriesSize(rays); 
    29322958 
    29332959        EvalSubdivisionStats(*splitCandidate); 
    … …  
    33333359                // create new interior node and two leaf node 
    33343360                const AxisAlignedPlane splitPlane = oldInterior->GetPlane(); 
    3335          
    33363361                sc->mSplitPlane = splitPlane; 
    33373362         
    … …  
    33393364                EvalSubdivisionCandidate(*sc, false); 
    33403365 
    3341                 newNode = SubdivideNode(splitPlane, tData, tFrontData, tBackData); 
     3366                newNode = SubdivideNode(*sc, tFrontData, tBackData); 
    33423367         
    33433368                //oldNode->mRenderCostDecr += sc->GetRenderCostDecrease(); 

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

    r1845 r1912  
    372372 
    373373                VspTraversalData(): 
    374                 mNode(NULL), 
    375                 mDepth(0), 
    376                 mRays(NULL), 
    377                 mPvs(0), 
    378                 mProbability(0.0), 
    379                 mMaxCostMisses(0),  
    380                 mPriority(0) 
     374                        mNode(NULL), 
     375                        mDepth(0), 
     376                        mRays(NULL), 
     377                        mPvs(0), 
     378                        mProbability(0.0), 
     379                        mMaxCostMisses(0),  
     380                        mPriority(0), 
     381                        mCorrectedPvs(0) 
    381382                {} 
    382383                 
    … …  
    387388                                                 const float p, 
    388389                                                 const AxisAlignedBox3 &box): 
    389                 mNode(node),  
    390                 mDepth(depth),  
    391                 mRays(rays), 
    392                 mPvs(pvs), 
    393                 mProbability(p), 
    394                 mBoundingBox(box), 
    395                 mMaxCostMisses(0), 
    396                 mPriority(0) 
     390                        mNode(node),  
     391                        mDepth(depth),  
     392                        mRays(rays), 
     393                        mProbability(p), 
     394                        mBoundingBox(box), 
     395                        mMaxCostMisses(0), 
     396                        mPriority(0), 
     397                        mCorrectedPvs(0), 
     398                        mPvs(pvs), 
     399                        mRenderCost(0), 
     400                        mCorrectedRenderCost(0) 
    397401                {} 
    398402 
    … …  
    400404                                                 RayInfoContainer *rays, 
    401405                                                 const AxisAlignedBox3 &box):  
    402                 mNode(NULL),  
    403                 mDepth(depth),  
    404                 mRays(rays), 
    405                 mPvs(0), 
    406                 mProbability(0), 
    407                 mMaxCostMisses(0), 
    408                 mBoundingBox(box) 
     406                        mNode(NULL),  
     407                        mDepth(depth),  
     408                        mRays(rays), 
     409                        mProbability(0), 
     410                        mMaxCostMisses(0), 
     411                        mBoundingBox(box), 
     412                        mCorrectedPvs(0), 
     413                        mPvs(0) , 
     414                        mRenderCost(0), 
     415                        mCorrectedRenderCost(0)  
    409416                {} 
    410417 
    … …  
    425432                                // delete old view cell 
    426433                                delete mNode->GetViewCell(); 
     434 
    427435                                delete mNode; 
    428436                                mNode = NULL; 
    … …  
    440448                /// the bounding box of the node 
    441449                AxisAlignedBox3 mBoundingBox; 
    442                 /// pvs size 
    443                 float mPvs; 
    444450                /// how often this branch has missed the max-cost ratio 
    445451                int mMaxCostMisses; 
    446452                // current priority 
    447453                float mPriority; 
    448  
    449                  
     454                /// pvs size 
     455                float mPvs; 
     456                /// the correction factor for this pvs 
     457                float mCorrectedPvs; 
     458                /// pvs size 
     459                float mRenderCost; 
     460                /// the correction factor for this pvs 
     461                float mCorrectedRenderCost; 
     462 
    450463                friend bool operator<(const VspTraversalData &a, const VspTraversalData &b) 
    451464                { 
    … …  
    460473        public: 
    461474 
    462                 static VspTree* sVspTree; 
    463  
    464                 /// the current split plane 
    465                 AxisAlignedPlane mSplitPlane; 
    466                 /// parent node traversal data 
    467                 VspTraversalData mParentData; 
    468                  
    469475                VspSubdivisionCandidate(const VspTraversalData &tData): mParentData(tData) 
    470476                {}; 
    … …  
    502508                } 
    503509 
    504         VspSubdivisionCandidate(const AxisAlignedPlane &plane, const VspTraversalData &tData):  
    505                 mSplitPlane(plane), mParentData(tData) 
     510                VspSubdivisionCandidate(const AxisAlignedPlane &plane, const VspTraversalData &tData):  
     511                        mSplitPlane(plane), mParentData(tData) 
    506512                {} 
    507513 
    … …  
    510516                        return mPriority; 
    511517                } 
     518 
     519                //////////////////// 
     520 
     521                static VspTree* sVspTree; 
     522 
     523                /// the current split plane 
     524                AxisAlignedPlane mSplitPlane; 
     525                /// parent node traversal data 
     526                VspTraversalData mParentData; 
     527         
     528                float mCorrectedFrontPvs; 
     529                float mCorrectedBackPvs; 
     530 
     531                float mCorrectedFrontRenderCost; 
     532                float mCorrectedBackRenderCost; 
    512533        }; 
    513534 
    … …  
    729750        /** Evaluates render cost decrease of next split. 
    730751        */ 
    731         float EvalRenderCostDecrease(const AxisAlignedPlane &candidatePlane, 
    732                                                                  const VspTraversalData &data, 
     752        float EvalRenderCostDecrease(VspSubdivisionCandidate &splitData,  
    733753                                                                 float &normalizedOldRenderCost) const; 
    734754 
    … …  
    790810                @returns the root of the subdivision 
    791811        */ 
    792         VspInterior *SubdivideNode(const AxisAlignedPlane &splitPlane, 
    793                                                            VspTraversalData &tData, 
     812        VspInterior *SubdivideNode(const VspSubdivisionCandidate &sc, 
    794813                                                           VspTraversalData &frontData, 
    795814                               VspTraversalData &backData); 
    … …  
    813832        */ 
    814833        void SortSubdivisionCandidates(const RayInfoContainer &rays,  
    815                                                         const int axis,  
    816                                                         float minBand,  
    817                                                         float maxBand); 
     834                                                                  const int axis,  
     835                                                                  float minBand,  
     836                                                                  float maxBand); 
    818837 
    819838        /** Evaluate render cost of this pvs. 
Note: See TracChangeset for help on using the changeset viewer.