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

Timestamp:

11/18/06 23:15:55 (18 years ago)

Author:

mattausch

Message:

 

File:

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

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

@@ -40 +40 @@
 
 // pvs penalty can be different from pvs size
-inline static float EvalPvsPenalty(const int pvs, 
-                                                                   const int lower,
-                                                                   const int upper)
+inline static float EvalPvsPenalty(const float pvs, 
+                                                                   const float lower,
+                                                                   const float upper)
 {
         // clamp to minmax values
@@ -734 +734 @@
                         
                 mTotalCost -= sc->GetRenderCostDecrease();
-                mTotalPvsSize += tFrontData.mPvs + tBackData.mPvs - tData.mPvs;
+                mTotalPvsSize += (int)(tFrontData.mPvs + tBackData.mPvs - tData.mPvs);
                 mPvsEntries += sc->GetPvsEntriesIncr();
 
@@ -932 +932 @@
 
         //-- compute pvs
-        frontData.mPvs = EvalPvsSize(*frontData.mRays);
-        backData.mPvs = EvalPvsSize(*backData.mRays);
+        frontData.mPvs = EvalPvsCost(*frontData.mRays);
+        backData.mPvs = EvalPvsCost(*backData.mRays);
                 
         //-- split front and back node geometry and compute area
@@ -1120 +1120 @@
 
 
-int VspTree::PrepareHeuristics(KdLeaf *leaf)
+float VspTree::PrepareHeuristics(KdLeaf *leaf)
 {       
-        int pvsSize = 0;
+        float pvsSize = 0;
         
         if (!leaf->Mailed())
@@ -1160 +1160 @@
 
 
-int VspTree::PrepareHeuristics(const RayInfoContainer &rays)
+float VspTree::PrepareHeuristics(const RayInfoContainer &rays)
 {       
         Intersectable::NewMail();
@@ -1166 +1166 @@
         BvhLeaf::NewMail();
 
-        int pvsSize = 0;
+        float pvsSize = 0;
 
         RayInfoContainer::const_iterator ri, ri_end = rays.end();
@@ -1243 +1243 @@
 
 void VspTree::EvalHeuristics(const SortableEntry &ci,
-                                                         int &pvsLeft,
-                                                         int &pvsRight) const
+                                                         float &pvsLeft,
+                                                         float &pvsRight) const
 {
         VssRay *ray = ci.ray;
@@ -1251 +1251 @@
         if (ci.type == SortableEntry::ERayMin)
         {
+                pvsLeft += EvalMinEventContribution(*ray, true);
 #if COUNT_ORIGIN_OBJECTS
-                pvsLeft += EvalMinEventContribution(*ray, true);
-#else
                 pvsLeft += EvalMinEventContribution(*ray, false);
 #endif
@@ -1259 +1258 @@
         else // eval changes in pvs causes by max event 
         {
+                pvsRight -= EvalMaxEventContribution(*ray, true);
 #if COUNT_ORIGIN_OBJECTS
-                pvsRight -= EvalMaxEventContribution(*ray, true);
-#else
                 pvsRight -= EvalMaxEventContribution(*ray, false);
 #endif
@@ -1271 +1269 @@
                                                                            const AxisAlignedBox3 &box,
                                                                            const int axis,
-                                                                           float &position)
-{
-        // get subset of rays
-        RayInfoContainer randomRays;
-        randomRays.reserve(mMaxTests);
-
-        RayInfoContainer *usedRays;
-
-        if (mMaxTests < (int)tData.mRays->size())
-        {
-                GetRayInfoSets(*tData.mRays, mMaxTests, randomRays);
-                usedRays = &randomRays;
-        }
-        else
-        {
-                usedRays = tData.mRays;
-        }
-
+                                                                           float &position,
+                                                                           const RayInfoContainer &usedRays)
+{
         const float minBox = box.Min(axis);
         const float maxBox = box.Max(axis);
@@ -1297 +1280 @@
         const float maxBand = minBox + mMaxBand * sizeBox;
 
-        SortSubdivisionCandidates(*usedRays, axis, minBand, maxBand);
+        SortSubdivisionCandidates(usedRays, axis, minBand, maxBand);
 
         // prepare the sweep
         // note: returns pvs size => no need t give pvs size as function parameter
-        const int pvsSize = PrepareHeuristics(*usedRays);
+        const float pvsCost = PrepareHeuristics(usedRays);
 
         // go through the lists, count the number of objects left and right
@@ -1307 +1290 @@
         // C = ct_div_ci  + (ql*rl + qr*rr)/queries
 
-        int pvsl = 0;
-        int pvsr = pvsSize;
-
-        int pvsBack = pvsl;
-        int pvsFront = pvsr;
-
-        float sum = (float)pvsSize * sizeBox;
+        float pvsl = 0;
+        float pvsr = pvsCost;
+
+        float pvsBack = pvsl;
+        float pvsFront = pvsr;
+
+        float sum = pvsCost * sizeBox;
         float minSum = 1e20f;
 
@@ -1327 +1310 @@
         BvhLeaf::NewMail();
 
-        //-- traverse through visibility events
-        vector<SortableEntry>::const_iterator ci, ci_end = mLocalSubdivisionCandidates->end();
-
-#ifdef GTPGTP_DEBUG
-        const float volRatio = tData.mBoundingBox.GetVolume() / (sizeBox * mBoundingBox.GetVolume());
+        const float volRatio = 
+                tData.mBoundingBox.GetVolume() / (sizeBox * mBoundingBox.GetVolume());
+
+        ////////
+        //-- iterate through visibility events
+
+        vector<SortableEntry>::const_iterator ci, 
+                ci_end = mLocalSubdivisionCandidates->end();
+
+#ifdef GTP_DEBUG
         const int leaves = mVspStats.Leaves();
         const bool printStats = ((axis == 0) && (leaves > 0) && (leaves < 90));
@@ -1370 +1358 @@
                         sum = pvsl * ((*ci).value - minBox) + pvsr * (maxBox - (*ci).value);
                         
-#ifdef GTPGTP_DEBUG
+#ifdef GTP_DEBUG
                         if (printStats)
                         {
@@ -1404 +1392 @@
         //-- compute cost
 
-        const int lowerPvsLimit = mViewCellsManager->GetMinPvsSize();
-        const int upperPvsLimit = mViewCellsManager->GetMaxPvsSize();
+        const float lowerPvsLimit = (float)mViewCellsManager->GetMinPvsSize();
+        const float upperPvsLimit = (float)mViewCellsManager->GetMaxPvsSize();
 
         const float pOverall = sizeBox;
@@ -1411 +1399 @@
         const float pFront = maxBox - position;
 
-        const float penaltyOld = EvalPvsPenalty(pvsSize, lowerPvsLimit, upperPvsLimit);
+        const float penaltyOld = EvalPvsPenalty(pvsCost, lowerPvsLimit, upperPvsLimit);
     const float penaltyFront = EvalPvsPenalty(pvsFront, lowerPvsLimit, upperPvsLimit);
         const float penaltyBack = EvalPvsPenalty(pvsBack, lowerPvsLimit, upperPvsLimit);
@@ -1423 +1411 @@
         }
         
-#ifdef GTPGTP_DEBUG
-        Debug << "\n§§§§ eval local cost §§§§" << endl
+//#ifdef GTP_DEBUG
+        cout << "\n((((( eval local cost )))))" << endl
                   << "back pvs: " << penaltyBack << " front pvs: " << penaltyFront << " total pvs: " << penaltyOld << endl 
                   << "back p: " << pBack * volRatio << " front p " << pFront * volRatio << " p: " << pOverall * volRatio << endl
                   << "old rc: " << oldRenderCost * volRatio << " new rc: " << newRenderCost * volRatio << endl
                   << "render cost decrease: " << oldRenderCost * volRatio - newRenderCost * volRatio << endl;
-#endif
+//#endif
         return ratio;
 }
@@ -1454 +1442 @@
                 mOnlyDrivingAxis || mCirculatingAxis;
         
+        // get subset of rays
+        RayInfoContainer randomRays;
+        randomRays.reserve(mMaxTests);
+
+        RayInfoContainer *usedRays;
+
+        if (mMaxTests < (int)tData.mRays->size())
+        {
+                GetRayInfoSets(*tData.mRays, mMaxTests, randomRays);
+                usedRays = &randomRays;
+        }
+        else
+        {
+                usedRays = tData.mRays;
+        }
+
         if (mCirculatingAxis)
         {
@@ -1460 +1464 @@
 
                 if (parent)
+                {
                         parentAxis = dynamic_cast<VspInterior *>(parent)->GetAxis();
+                }
 
                 sAxis = (parentAxis + 1) % 3;
@@ -1476 +1482 @@
                         {
                                 //-- place split plane using heuristics
+
                                 nCostRatio[axis] =
                                         EvalLocalCostHeuristics(tData,
                                                                                         box,
                                                                                         axis,
-                                                                                        nPosition[axis]);                       
+                                                                                        nPosition[axis],
+                                                                                        *usedRays);                     
                         }
                         else
                         {
                                 //-- split plane position is spatial median                             
+                                
                                 nPosition[axis] = (box.Min()[axis] + box.Max()[axis]) * 0.5f;
                                 nCostRatio[axis] = EvalLocalSplitCost(tData,
@@ -1505 +1514 @@
         }
 
-        ////////////////////////////////
+        /////////////////////////
         //-- assign values of best split
 
@@ -1571 +1580 @@
 
 
-        ////////////////////////////////////
+        ///////////////////
         //-- evaluate render cost heuristics
 
-        const int lowerPvsLimit = mViewCellsManager->GetMinPvsSize();
-        const int upperPvsLimit = mViewCellsManager->GetMaxPvsSize();
-
-        const float penaltyOld = EvalPvsPenalty((int)totalPvs, lowerPvsLimit, upperPvsLimit);
-    const float penaltyFront = EvalPvsPenalty((int)pvsFront, lowerPvsLimit, upperPvsLimit);
-        const float penaltyBack = EvalPvsPenalty((int)pvsBack, lowerPvsLimit, upperPvsLimit);
+        const float lowerPvsLimit = (float)mViewCellsManager->GetMinPvsSize();
+        const float upperPvsLimit = (float)mViewCellsManager->GetMaxPvsSize();
+
+        const float penaltyOld = EvalPvsPenalty(totalPvs, lowerPvsLimit, upperPvsLimit);
+    const float penaltyFront = EvalPvsPenalty(pvsFront, lowerPvsLimit, upperPvsLimit);
+        const float penaltyBack = EvalPvsPenalty(pvsBack, lowerPvsLimit, upperPvsLimit);
                         
         const float oldRenderCost = pOverall * penaltyOld;
@@ -1590 +1599 @@
         const float renderCostDecrease = (oldRenderCost - newRenderCost) / viewSpaceVol;
 
-#ifdef GTPGTP_DEBUG
+#ifdef GTP_DEBUG
         Debug << "\nvsp render cost decrease" << endl
                   << "back pvs: " << pvsBack << " front pvs " << pvsFront << " total pvs: " << totalPvs << endl 
@@ -1619 +1628 @@
         KdLeaf::NewMail(3);
 
-        const int pvsSize = data.mPvs;
+        const float pvsSize = data.mPvs;
         RayInfoContainer::const_iterator rit, rit_end = data.mRays->end();
 
@@ -1863 +1872 @@
         if (data.mPvs > mVspStats.maxPvs)
         {
-                mVspStats.maxPvs = data.mPvs;
-        }
-
-        mVspStats.pvs += data.mPvs;
+                mVspStats.maxPvs = (int)data.mPvs;
+        }
+
+        mVspStats.pvs += (int)data.mPvs;
 
         if (data.mDepth < mVspStats.minDepth)
@@ -2215 +2224 @@
 
 
-int VspTree::EvalPvsSize(const RayInfoContainer &rays) const
-{
-        int pvsSize = 0;
+float VspTree::EvalPvsCost(const RayInfoContainer &rays) const
+{
+        float pvsCost = 0;
         
         Intersectable::NewMail();
@@ -2228 +2237 @@
         {
                 VssRay *ray = (*rit).mRay;
+                
+                pvsCost += EvalContributionToPvs(*ray, true);
+
 #if COUNT_ORIGIN_OBJECTS
-                pvsSize += EvalContributionToPvs(*ray, true);
-#else
-                pvsSize += EvalContributionToPvs(*ray, false);
+                pvsCost += EvalContributionToPvs(*ray, false);
 #endif
         }
         
-        return pvsSize;
+        return pvsCost;
 }
 
@@ -2307 +2317 @@
         {
                 VssRay *ray = (*rit).mRay;
+
+                pvsSize += EvalPvsEntriesContribution(*ray, true);
+
 #if COUNT_ORIGIN_OBJECTS
-                pvsSize += EvalPvsEntriesContribution(*ray, true);
-#else
                 pvsSize += EvalPvsEntriesContribution(*ray, false);
 #endif
@@ -2890 +2901 @@
 
         /// collect pvs from rays
-        const int pvsSize = EvalPvsSize(rays);
+        const float pvsCost = EvalPvsCost(rays);
         
         // root and bounding box were already constructed
@@ -2901 +2912 @@
         
         // first vsp traversal data
-        VspTraversalData vData(leaf, 0, &rays, pvsSize, prop, mBoundingBox);
+        VspTraversalData vData(leaf, 0, &rays, pvsCost, prop, mBoundingBox);
 
 
@@ -2923 +2934 @@
         leaf->SetSubdivisionCandidate(splitCandidate);
 
-        mTotalCost = (float)pvsSize;
+        mTotalCost = pvsCost;
         mPvsEntries = EvalPvsEntriesSize(rays);
 
@@ -3057 +3068 @@
 
 
-int VspTree::PrepareHeuristics(const VssRay &ray, const bool isTermination)
-{
-        int pvsSize = 0;
+float VspTree::PrepareHeuristics(const VssRay &ray, const bool isTermination)
+{
+        float pvsSize = 0;
         
         Intersectable *obj;