Changeset 474 for trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp

Timestamp:

12/21/05 10:53:47 (19 years ago)

Author:

mattausch

Message:

 

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp (modified) (11 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp

@@ -38 +38 @@
 mRoot(NULL),
 mPvsUseArea(true),
-mNumCriteria(0)
+mCostNormalizer(Limits::Small)
 {
         mRootCell = new BspViewCell();
@@ -91 +91 @@
         Debug << "max polygon candidates: " << mMaxPolyCandidates << endl;
         Debug << "max plane candidates: " << mMaxRayCandidates << endl;
-
+        
         Debug << "Split plane strategy: ";
         if (mSplitPlaneStrategy & RANDOM_POLYGON)
+        {
                 Debug << "random polygon ";
-
+        }
         if (mSplitPlaneStrategy & AXIS_ALIGNED)
         {
-                ++ mNumCriteria;
                 Debug << "axis aligned ";
         }
         if (mSplitPlaneStrategy & LEAST_RAY_SPLITS)
         {
-                ++ mNumCriteria;
+                mCostNormalizer += mLeastRaySplitsFactor;
                 Debug << "least ray splits ";
         }
         if (mSplitPlaneStrategy & BALANCED_RAYS)
         {
-                ++ mNumCriteria;
+                mCostNormalizer += mBalancedRaysFactor;
                 Debug << "balanced rays ";
         }
         if (mSplitPlaneStrategy & PVS)
         {
-                ++ mNumCriteria;
+                mCostNormalizer += mPvsFactor;
                 Debug << "pvs";
         }
@@ -273 +273 @@
         }
 
+        mTermMinArea *= mBox.SurfaceArea(); // normalize
         mStat.polys = (int)polys.size();
 
@@ -315 +316 @@
 
             tStack.pop();
-
                 // subdivide leaf node
                 BspNode *r = Subdivide(tStack, tData);
@@ -412 +412 @@
                 ++ maxCostMisses;
 
-                /*if (maxCostMisses >= mTermMissTolerance)
+                if (maxCostMisses >= mTermMissTolerance)
                 {
                         // terminate branch because of max cost
                         ++ mStat.maxCostNodes; 
             return leaf;
-                }*/
+                }
         }
 
@@ -471 +471 @@
                                                                            mEpsilon);
         
-                // area is normalized with view space area
-                frontData.mArea = frontData.mGeometry->GetArea() / mBox.SurfaceArea();
-                backData.mArea = backData.mGeometry->GetArea() / mBox.SurfaceArea();
+                frontData.mArea = frontData.mGeometry->GetArea();
+                backData.mArea = backData.mGeometry->GetArea();
         }
 
@@ -810 +809 @@
                 const int candidateIdx = (int)RandomValue(0, (Real)(-- maxIdx));
                 //Debug << "current Idx: " << maxIdx << " cand idx " << candidateIdx << endl;
-
+                
                 Polygon3 *poly = (*data.mPolygons)[candidateIdx];
-                
+
                 // swap candidate to the end to avoid testing same plane
                 std::swap((*data.mPolygons)[maxIdx], (*data.mPolygons)[candidateIdx]);
-
+        
                 //Polygon3 *poly = (*data.mPolygons)[(int)RandomValue(0, (int)polys.size() - 1)];
 
@@ -829 +828 @@
         }
         
-        //Debug << "lowest: " << lowestCost << endl;
-
         //-- choose candidate planes extracted from rays
-        // we use different methods chosen with
-        // equal probability
+        //-- different methods are available
         for (int i = 0; i < mMaxRayCandidates; ++ i)
         {
                 plane = ChooseCandidatePlane3(*data.mRays);
-
                 const float candidateCost = SplitPlaneCost(plane, data);
 
@@ -846 +841 @@
                 }
         }
+
+#ifdef _DEBUG
+        Debug << "plane lowest cost: " << lowestCost << endl;
+#endif
 
         // cost ratio miss
         if (lowestCost > mTermMaxCostRatio)
                 return false;
-
-#ifdef _DEBUG
-        Debug << "plane lowest cost: " << lowestCost << endl;
-#endif
 
         return true;
@@ -1011 +1006 @@
         {
                 const float oldCost = pOverall * (float)data.mPvs + Limits::Small;
-
-                cost += mPvsFactor * (frontPvs * pFront + (backPvs * pBack)) / oldCost;
-
-                // give penalty to unbalanced split
-                if (0)
-                if (((pFront * 0.2 + Limits::Small) > pBack) || 
-                        (pFront < (pBack * 0.2 + Limits::Small)))
-                        cost += 0.5;
+                cost += mPvsFactor * (frontPvs * pFront + backPvs * pBack) / oldCost;
+
+                //cost += mPvsFactor * 0.5 * (frontPvs * pFront + backPvs * pBack) / oldCost;
+                //Debug << "new cost: " << cost << " over" << frontPvs * pFront + backPvs * pBack << " old cost " << oldCost << endl;
+        
+                if (0) // give penalty to unbalanced split
+                        if (((pFront * 0.2 + Limits::Small) > pBack) || 
+                                (pFront < (pBack * 0.2 + Limits::Small)))
+                                        cost += 0.5;
         }
 
 #ifdef _DEBUG
-//      Debug << "totalpvs: " << pvs << " ptotal: " << pOverall
-//                << " frontpvs: " << frontPvs << " pFront: " << pFront 
-//                << " backpvs: " << backPvs << " pBack: " << pBack << endl << endl;
+        Debug << "totalpvs: " << data.mPvs << " ptotal: " << pOverall
+                  << " frontpvs: " << frontPvs << " pFront: " << pFront 
+                  << " backpvs: " << backPvs << " pBack: " << pBack << endl << endl;
 #endif
-
-        // normalize by number of criteria
-        return cost / (float)(mNumCriteria + Limits::Small);
+        
+        // normalize cost by sum of linear factors
+        return cost / (float)mCostNormalizer;
 }
 
@@ -1118 +1114 @@
         if (data.mDepth < mStat.minDepth)
                 mStat.minDepth = data.mDepth;
-
+        
+        if (data.mDepth >= mTermMaxDepth)
+                ++ mStat.maxDepthNodes;
+
+        if (data.mPvs < mTermMinPvs)
+                ++ mStat.minPvsNodes;
+
+        if ((int)data.mRays->size() < mTermMinRays)
+                ++ mStat.minRaysNodes;
+
+        if (data.GetAvgRayContribution() > mTermMaxRayContribution)
+                ++ mStat.maxRayContribNodes;
+        
+        if (data.mArea <= mTermMinArea) 
+        {
+                //Debug << "area: " << data.mArea / mBox.SurfaceArea() << " min area: " << mTermMinArea / mBox.SurfaceArea() << endl;
+                ++ mStat.minAreaNodes;
+        }
         // accumulate depth to compute average depth
         mStat.accumDepth += data.mDepth;
-        
-
-        if (data.mDepth >= mTermMaxDepth)
-                ++ mStat.maxDepthNodes;
-
-        if (data.mPvs < mTermMinPvs)
-                ++ mStat.minPvsNodes;
-
-        if ((int)data.mRays->size() < mTermMinRays)
-                ++ mStat.minRaysNodes;
-
-        if (data.GetAvgRayContribution() > mTermMaxRayContribution)
-                ++ mStat.maxRayContribNodes;
-        
-        if (data.mGeometry->GetArea() <= mTermMinArea) 
-                ++ mStat.minAreaNodes;
 
 #ifdef _DEBUG