Changeset 607

Timestamp:

02/08/06 18:25:17 (18 years ago)

Author:

mattausch

Message:

added method for associating spatial hierarchy leaf with view cell

Location:

trunk/VUT/GtpVisibilityPreprocessor

Files:

• scripts/default.env (modified) (6 diffs)
• src/Environment.cpp (modified) (1 diff)
• src/ViewCell.cpp (modified) (3 diffs)
• src/ViewCellsManager.cpp (modified) (2 diffs)
• src/ViewCellsManager.h (modified) (2 diffs)
• src/VspBspTree.cpp (modified) (5 diffs)
• src/VspBspTree.h (modified) (2 diffs)

trunk/VUT/GtpVisibilityPreprocessor/scripts/default.env

@@ -176 +176 @@
         # samples used for view cell construction
         Construction {
-                samples 2500000
+                samples 2000000
                 samplesPerPass 500000
         }
 
         #number of active view cells
-        active 256
+        active 2048
         maxStaticMemory 40
 
@@ -188 +188 @@
 
         #type kdTree
-        type vspKdTree
+        #type vspKdTree
         #type bspTree
         type vspBspTree
@@ -214 +214 @@
                 refine false
                 compress false
-                merge false
+                merge true
         }
 
@@ -304 +304 @@
         
         # maximal candidates for split planes
-        maxPolyCandidates 0
+        maxPolyCandidates 200
 
         
         # maximal tested rays for split cost heuristics
-        maxTests 20000
+        maxTests 10000
         
         maxTotalMemory  50
@@ -320 +320 @@
         }
         
+        usePolygonSplitIfAvailable 0
+
         Termination {
                 # parameters used for autopartition
-                minRays                 -1
+                minRays                 500
                 minPolygons             -1
-                maxDepth                40
+                maxDepth                25
                 minPvs                  -1
                 minProbability          0.0000001
-                maxRayContribution      100000000.2
-                maxCostRatio            9.85
-                missTolerance           2
-                
-                maxViewCells            2048
+                maxRayContribution      0.3
+                maxCostRatio            0.9
+                missTolerance           3
+                
+                maxViewCells            30000
                 
                 # used for pvs criterium
@@ -337 +339 @@
                 
                 AxisAligned {
-                        minRays                 1
+                        minRays                 900000
                         maxRayContribution      9.9
                 }
         }
         
-        splitUseOnlyDrivingAxis true
+        splitUseOnlyDrivingAxis false
         
         Visualization {

trunk/VUT/GtpVisibilityPreprocessor/src/Environment.cpp

@@ -1909 +1909 @@
                                         "false");
 
+        RegisterOption("VspBspTree.usePolygonSplitIfAvailable",
+                                        optBool,
+                    "vsp_bsp_usePolygonSplitIfAvailable=",
+                                        "true");
+
         RegisterOption("VspBspTree.Termination.AxisAligned.minRays",
                         optInt,

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCell.cpp

@@ -497 +497 @@
         cout << "actual merge starts now ... " << endl;
         
-
         mStats << "#Pass\n" << pass << endl
                    << "#Merged\n" << mergeStats.merged << endl 
-                   << "#Viewcells\n" << realNumActiveViewCells << endl 
+                   << "#ViewCells\n" << realNumActiveViewCells << endl 
                    << "#RenderCostIncrease\n" << 0 << endl
                    << "#TotalRenderCost\n" << totalRenderCost << endl
@@ -508 +507 @@
                    << "#Deviation\n" << mDeviation << endl
                    << "#TotalPvs\n" << totalPvs << endl
-                   << "#PvsSizeDecrease\n" << 0 << endl
-                   << "#Volume\n" << endl;
+                   << "#PvsSizeDecrease\n0" << endl
+                   << "#Volume\n" << endl
+                   << "#Siblings\n" << mergeStats.siblings << endl;
 
         //-- use priority queue to merge leaf pairs
@@ -604 +604 @@
                         mergedVc->SetMergeCost(totalRenderCost);
 
-#if VC_HISTORY
-                        if (mc.mLeftViewCell->IsSibling(mc.mRightViewCell))
+                        if (mViewCellsManager->EqualToSpatialNode(mergedVc))
                                 ++ mergeStats.siblings;
-#endif
+
                         if (((mergeStats.merged % statsOut) == 0) || 
                         (realNumActiveViewCells == mMergeMinViewCells))

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.cpp

@@ -113 +113 @@
 
 
+
 /// helper function which destroys rays or copies them into the output ray container
 inline void addOutRays(VssRayContainer &rays, VssRayContainer *outRays)
@@ -2612 +2613 @@
 
 
+bool VspBspViewCellsManager::EqualToSpatialNode(ViewCell *viewCell)
+{
+        BspNode *node;
+        return EqualToSpatialNode(viewCell, &node);
+}
+
+
+bool VspBspViewCellsManager::EqualToSpatialNode(ViewCell *viewCell, BspNode **node)
+{
+        if (!viewCell->IsLeaf())
+        {
+                BspViewCell *bspVc = dynamic_cast<BspViewCell *>(viewCell);
+
+                *node = bspVc->mLeaf;
+        return true;
+        }
+        else
+        {
+                ViewCellInterior *interior = dynamic_cast<ViewCellInterior *>(viewCell);
+
+                // cannot be node of binary tree
+                if (interior->mChildren.size() != 2)
+                        return false;
+
+                ViewCell *left = interior->mChildren[0];
+                ViewCell *right = interior->mChildren[1];
+
+                BspNode *leftNode;
+                BspNode *rightNode;
+
+                if (EqualToSpatialNode(left, &leftNode) && EqualToSpatialNode(right, &rightNode))
+                {
+                        *node = leftNode->GetParent();
+                        return leftNode->IsSibling(rightNode);  
+                }
+
+                *node = NULL;
+
+                return false;
+        }
+}
+
+
 void VspBspViewCellsManager::RefineViewCells(const VssRayContainer &rays,
                                                                                          const ObjectContainer &objects)

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.h

@@ -352 +352 @@
                                                                                 vector<MergeCandidate> &candidates) = 0;
 
-        
-  
-  void CollectViewCells(const int n) {
-        mNumActiveViewCells = n;
-        mViewCells.clear();
-        CollectViewCells();
-  }
+         
+        void CollectViewCells(const int n) 
+        {
+                mNumActiveViewCells = n;
+                mViewCells.clear();
+                CollectViewCells();
+        }
+
+        bool EqualToSpatialNode(ViewCell *viewCell) { return false;} // implemented in subclasses
+
 
 
 protected:
-
+        
 
         /**
@@ -753 +756 @@
         void CollectMergeCandidates(const VssRayContainer &rays, vector<MergeCandidate> &candidates);
 
+        bool EqualToSpatialNode(ViewCell *viewCell);
+
 protected:
+
+        bool EqualToSpatialNode(ViewCell *viewCell, BspNode **node);
 
         /** HACK

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp

@@ -116 +116 @@
         environment->GetFloatValue("VspBspTree.Construction.renderCostWeight", mRenderCostWeight);
 
+        environment->GetBoolValue("VspBspTree.usePolygonSplitIfAvailable", mUsePolygonSplitIfAvailable);
 
         mSubdivisionStats.open("subdivisionStats.log");
@@ -431 +432 @@
 
         mTotalCost = tData.mPvs * tData.mProbability / mBox.GetVolume();
-
+        mTotalPvsSize = tData.mPvs;
+        
         mSubdivisionStats 
                         << "#ViewCells\n1\n" <<  endl
                         << "#RenderCostDecrease\n0\n" << endl 
-                        << "#TotalRenderCost\n" << mTotalCost << endl;
+                        << "#TotalRenderCost\n" << mTotalCost << endl
+                        << "#AvgRenderCost\n" << mTotalPvsSize << endl;
 
         Debug << "total cost: " << mTotalCost << endl;
@@ -533 +536 @@
                                 float cData = tData.mPvs * tData.mProbability;;
 
-                                float costDecr = 
+                float costDecr = 
                                         (cFront + cBack - cData) / mBox.GetVolume();
+
+                                int pvsFront = tFrontData.mPvs * tFrontData.mProbability;
+                                int pvsBack = tBackData.mPvs * tBackData.mProbability;
+                                int pvsData = tData.mPvs * tData.mProbability;;
+
                                 mTotalCost += costDecr;
+                                mTotalPvsSize += tFrontData.mPvs + tBackData.mPvs - tData.mPvs;
 
                                 mSubdivisionStats 
                                                 << "#ViewCells\n" << mBspStats.Leaves() << endl
                                                 << "#RenderCostDecrease\n" << -costDecr << endl 
-                                                << "#TotalRenderCost\n" << mTotalCost << endl;
+                                                << "#TotalRenderCost\n" << mTotalCost << endl
+                                                << "#AvgRenderCost\n" << mTotalPvsSize / mBspStats.Leaves() << endl;
                         }
 
@@ -1111 +1121 @@
         }
 
+        // cost ratio miss
+        if (!mUsePolygonSplitIfAvailable || data.mPolygons->empty())
+        {
+                frontData.mIsKdNode = backData.mIsKdNode = false;
+                if (lowestCost > mTermMaxCostRatio)
+                        return false;
+
+                return true;
+        }
+
         //-- evaluate axis aligned splits
         int axis;
@@ -1361 +1381 @@
 
                 // only render cost heuristics or combined with standard deviation
+                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 * (float)penaltyOld + Limits::Small;
+                const float newRenderCost = penaltyFront * pFront + penaltyBack * pBack;
+
+                float oldCost, newCost;
+
+                // only render cost
                 if (1)
                 {
-                        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 * (float)penaltyOld + Limits::Small;
-                        const float newRenderCost = penaltyFront * pFront + penaltyBack * pBack;
-
-                        float oldCost, newCost;
-
-                        // only render cost
-                        if (1)
-                        {
-                                oldCost = oldRenderCost;
-                                newCost = newRenderCost;
-                        }
-                        else // also considering standard deviation
-                        {
-                                // standard deviation is difference of back and front pvs
-                                const float expectedCost = 0.5f * (penaltyFront + penaltyBack);
-
-                                const float newDeviation = 0.5f * 
-                                        fabs(penaltyFront - expectedCost) + fabs(penaltyBack - expectedCost);
-
-                const float oldDeviation = penaltyOld + Limits::Small;
-
-                                newCost = mRenderCostWeight * newRenderCost + (1.0f - mRenderCostWeight) * newDeviation;
-                                oldCost = mRenderCostWeight * oldRenderCost + (1.0f - mRenderCostWeight) * oldDeviation;
-                        }
-
-                        cost += mPvsFactor * newCost / oldCost;
-                }
+                        oldCost = oldRenderCost;
+                        newCost = newRenderCost;
+                }
+                else // also considering standard deviation
+                {
+                        // standard deviation is difference of back and front pvs
+                        const float expectedCost = 0.5f * (penaltyFront + penaltyBack);
+
+                        const float newDeviation = 0.5f * 
+                                fabs(penaltyFront - expectedCost) + fabs(penaltyBack - expectedCost);
+
+                        const float oldDeviation = penaltyOld + Limits::Small;
+
+                        newCost = mRenderCostWeight * newRenderCost + (1.0f - mRenderCostWeight) * newDeviation;
+                        oldCost = mRenderCostWeight * oldRenderCost + (1.0f - mRenderCostWeight) * oldDeviation;
+                }
+
+                cost += mPvsFactor * newCost / oldCost;
+                
         }
 

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.h

@@ -706 +706 @@
         
         float mTotalCost;
+        int mTotalPvsSize;
+
         int mSplits;
 
@@ -711 +713 @@
 
         bool mUseRandomAxis;
+
+        bool mUsePolygonSplitIfAvailable;
+
 private: