Changeset 1912 for GTP/trunk/Lib/Vis/Preprocessing/src/VspTree.cpp

Timestamp:

12/20/06 00:26:02 (17 years ago)

Author:

mattausch

Message:

 

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/VspTree.cpp (modified) (19 diffs)

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

@@ -724 +724 @@
                 
                 // create new interior node and two leaf node
-                const AxisAlignedPlane splitPlane = sc->mSplitPlane;
                 const int maxCostMisses = sc->GetMaxCostMisses();
 
-                newNode = SubdivideNode(splitPlane, tData, tFrontData, tBackData);
+                newNode = SubdivideNode(*sc,
+                                                                tFrontData, 
+                                                                tBackData);
         
                 // how often was max cost ratio missed in this branch?
@@ -832 +833 @@
         
         VspLeaf *leaf = dynamic_cast<VspLeaf *>(splitCandidate.mParentData.mNode);
-        
+
+        /////////////
+        // avg ray contri
+
+        const int pvs = EvalPvsEntriesSize(*splitCandidate.mParentData.mRays);
+
+        const float avgRayContri = (float)pvs / 
+                ((float)splitCandidate.mParentData.mRays->size() + Limits::Small);
+
+        splitCandidate.SetAvgRayContribution(avgRayContri);
+        cout << "vsp avg ray contri: " << avgRayContri << endl;
+
         // compute global decrease in render cost
         float oldRenderCost;
-        const float renderCostDecr = EvalRenderCostDecrease(splitCandidate.mSplitPlane, 
-                                                                                                                splitCandidate.mParentData,
-                                                                                                                oldRenderCost);
-
+        const float renderCostDecr = EvalRenderCostDecrease(splitCandidate, oldRenderCost);
         splitCandidate.SetRenderCostDecrease(renderCostDecr);
 
@@ -854 +863 @@
         {
                 priority /= ((float)splitCandidate.GetPvsEntriesIncr() + mMemoryConst);
-        }
-
-
-        /////////////
-        // avg ray contri
-
-        if (USE_AVGRAYCONTRI)
-        {
-                const int pvs = EvalPvsEntriesSize(*splitCandidate.mParentData.mRays);
-
-                const float avgRayContri = (float)pvs / 
-                        ((float)splitCandidate.mParentData.mRays->size() + Limits::Small);
-
-                splitCandidate.SetAvgRayContribution(avgRayContri);
         }
 
@@ -904 +899 @@
         }
 
-        return (int)(fPvsSize + bPvsSize - oldPvsSize);
-}
-
-
-VspInterior *VspTree::SubdivideNode(const AxisAlignedPlane &splitPlane,
-                                                                        VspTraversalData &tData,
+        const float oldPvsRatio = oldPvsSize / splitCandidate.mParentData.mPvs;
+        const float correctedOldPvs = splitCandidate.mParentData.mCorrectedPvs * oldPvsRatio;
+
+        cout <<"here102 "<< endl;
+        cout << "old pvs ratio: " << oldPvsRatio << endl;
+        const float correctedFrontPvs = 
+                mHierarchyManager->EvalCorrectedPvs(fPvsSize, 
+                                                                                        correctedOldPvs, 
+                                                                                        splitCandidate.GetAvgRayContribution());
+        cout <<"here103 "<< endl;
+        const float correctedBackPvs = 
+                mHierarchyManager->EvalCorrectedPvs(bPvsSize, 
+                                                                                        correctedOldPvs, 
+                                                                                        splitCandidate.GetAvgRayContribution());
+
+        
+        cout << "vsp front entries " << fPvsSize << " corrected: " << correctedFrontPvs << endl;
+        cout << "vsp back entries " << bPvsSize << " corrected: " << correctedBackPvs << endl;
+
+        return (int)(correctedFrontPvs + correctedBackPvs - correctedOldPvs);
+}
+
+
+VspInterior *VspTree::SubdivideNode(const VspSubdivisionCandidate &sc,
                                                                         VspTraversalData &frontData,
                                                                         VspTraversalData &backData)
 {
-        VspLeaf *leaf = dynamic_cast<VspLeaf *>(tData.mNode);
-        
+        VspLeaf *leaf = dynamic_cast<VspLeaf *>(sc.mParentData.mNode);
+
+        const VspTraversalData &tData = sc.mParentData;
+        const AxisAlignedPlane splitPlane = sc.mSplitPlane;
+
         ///////////////
         //-- new traversal values
@@ -928 +944 @@
 
         //-- compute pvs
-        frontData.mPvs = EvalPvsCost(*frontData.mRays);
-        backData.mPvs = EvalPvsCost(*backData.mRays);
-                
+        frontData.mPvs = (float)EvalPvsEntriesSize(*frontData.mRays);
+        backData.mPvs = (float)EvalPvsEntriesSize(*backData.mRays);
+        
+        //-- compute pvs correction for coping with undersampling
+        frontData.mCorrectedPvs = sc.mCorrectedFrontPvs;
+        backData.mCorrectedPvs = sc.mCorrectedBackPvs;
+
         //-- split front and back node geometry and compute area
         tData.mBoundingBox.Split(splitPlane.mAxis, 
@@ -940 +960 @@
         backData.mProbability = tData.mProbability - frontData.mProbability;
 
+        //-- compute render cost
+        frontData.mRenderCost = (float)EvalRenderCost(*frontData.mRays);
+        backData.mRenderCost = (float)EvalRenderCost(*backData.mRays);
+        
+        frontData.mCorrectedRenderCost = sc.mCorrectedFrontPvs;
+        backData.mCorrectedRenderCost = sc.mCorrectedBackPvs;
 
         ////////
@@ -1519 +1545 @@
 
 
-float VspTree::EvalRenderCostDecrease(const AxisAlignedPlane &candidatePlane,
-                                                                          const VspTraversalData &tData,
-                                                                          float &normalizedOldRenderCost,
-                                                                          const float avgRayContri) const
+float VspTree::EvalRenderCostDecrease(VspSubdivisionCandidate &sc,
+                                                                          float &normalizedOldRenderCost) const
 {
         float pvsFront = 0;
@@ -1529 +1553 @@
 
         const float viewSpaceVol = mBoundingBox.GetVolume();
+        const VspTraversalData &tData = sc.mParentData;
+        
+        const AxisAlignedPlane &candidatePlane = sc.mSplitPlane;
+        const float avgRayContri = sc.GetAvgRayContribution();
 
         //////////////////////////////////////////////
@@ -1537 +1565 @@
         KdLeaf::NewMail(3);
 
-        RayInfoContainer::const_iterator rit, rit_end = data.mRays->end();
-
-        for (rit = data.mRays->begin(); rit != rit_end; ++ rit)
+        RayInfoContainer::const_iterator rit, rit_end = tData.mRays->end();
+
+        for (rit = tData.mRays->begin(); rit != rit_end; ++ rit)
         {
                 RayInfo rayInf = *rit;
@@ -1563 +1591 @@
         AxisAlignedBox3 backBox;
 
-        data.mBoundingBox.Split(candidatePlane.mAxis, 
-                                                        candidatePlane.mPosition, 
-                                                        frontBox, 
-                                                        backBox);
-
-        // probability that view point lies in back / front node
-        float pOverall = data.mProbability;
+        tData.mBoundingBox.Split(candidatePlane.mAxis, 
+                                                         candidatePlane.mPosition, 
+                                                         frontBox, 
+                                                         backBox);
+
+    // probability that view point lies in back / front node
+        float pOverall = tData.mProbability;
         float pFront = frontBox.GetVolume();
         float pBack = pOverall - pFront;
@@ -1576 +1604 @@
         ///////////////////
         //-- evaluate render cost heuristics
-#if 0
-        const float penaltyOld = totalPvs;
-
-    const float penaltyFront = pvsFront;
-        const float penaltyBack = pvsBack;
-#else
-        const float penaltyOld = totalPvs * tData.mPvsCorrectionFactor;
-
-        const float frontCorr = mHierarchyManager->EvalPvsCorrectionFactor(pvsFront, penaltyOld, avgRayContri);
-        const float backCorr = mHierarchyManager->EvalPvsCorrectionFactor(pvsBack, penaltyOld, avgRayContri);
-
-        const float penaltyFront = frontCorr;
-        const float penaltyBack = pvsBack * backCorr;;
-#endif
+
+        const float oldRenderCostRatio = tData.mPvs ? (totalPvs / tData.mPvs) : 1;
+
+        const float penaltyOld = tData.mCorrectedPvs * oldRenderCostRatio;
+
+        cout <<"here107 " << penaltyOld << endl;
+        sc.mCorrectedFrontPvs = mHierarchyManager->EvalCorrectedPvs(pvsFront, penaltyOld, avgRayContri);
+        cout <<"here108 " << tData.mCorrectedPvs << " " << oldRenderCostRatio << endl;
+        sc.mCorrectedBackPvs = mHierarchyManager->EvalCorrectedPvs(pvsBack, penaltyOld, avgRayContri);
+
+        cout << "vsp front pvs " << pvsFront << " corrected: " << sc.mCorrectedFrontPvs << endl;
+        cout << "vsp back pvs " << pvsBack << " corrected: " << sc.mCorrectedBackPvs << endl;
 
         const float oldRenderCost = pOverall * penaltyOld;
-        const float newRenderCost = penaltyFront * pFront + penaltyBack * pBack;
+        const float newRenderCost = sc.mCorrectedFrontPvs * pFront + sc.mCorrectedBackPvs * pBack;
 
         // we also return the old render cost
@@ -1612 +1638 @@
 
 
-float VspTree::EvalLocalSplitCost(const VspTraversalData &data,
+float VspTree::EvalLocalSplitCost(const VspTraversalData &tData,
                                                                   const AxisAlignedBox3 &box,
                                                                   const int axis,
@@ -1627 +1653 @@
         KdLeaf::NewMail(3);
 
-        const float pvsSize = data.mPvs;
-        RayInfoContainer::const_iterator rit, rit_end = data.mRays->end();
+        RayInfoContainer::const_iterator rit, rit_end = tData.mRays->end();
 
         // this is the main ray classification loop!
-        for(rit = data.mRays->begin(); rit != rit_end; ++ rit)
+        for(rit = tData.mRays->begin(); rit != rit_end; ++ rit)
         {
                 VssRay *ray = (*rit).mRay;
@@ -1645 +1670 @@
         //////////////
         //-- evaluate cost heuristics
-        float pOverall = data.mProbability;
+
+        float pOverall = tData.mProbability;
 
         // we use spatial mid split => simplified computation
@@ -1651 +1677 @@
         
         const float newCost = pvsBack * pBack + pvsFront * pFront;
-        const float oldCost = (float)pvsSize * pOverall + Limits::Small;
+        const float oldCost = (float)pvsTotal * pOverall + Limits::Small;
         
 #ifdef GTPGTP_DEBUG
@@ -2921 +2947 @@
 #endif
 
+        mTotalCost = vData.mCorrectedPvs = pvsCost;
+        mPvsEntries = EvalPvsEntriesSize(rays);
+
         //////////////
         //-- create the first split candidate
@@ -2927 +2956 @@
     EvalSubdivisionCandidate(*splitCandidate);
         leaf->SetSubdivisionCandidate(splitCandidate);
-
-        mTotalCost = pvsCost;
-        mPvsEntries = EvalPvsEntriesSize(rays);
 
         EvalSubdivisionStats(*splitCandidate);
@@ -3333 +3359 @@
                 // create new interior node and two leaf node
                 const AxisAlignedPlane splitPlane = oldInterior->GetPlane();
-        
                 sc->mSplitPlane = splitPlane;
         
@@ -3339 +3364 @@
                 EvalSubdivisionCandidate(*sc, false);
 
-                newNode = SubdivideNode(splitPlane, tData, tFrontData, tBackData);
+                newNode = SubdivideNode(*sc, tFrontData, tBackData);
         
                 //oldNode->mRenderCostDecr += sc->GetRenderCostDecrease();