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

Timestamp:

10/05/06 18:51:15 (18 years ago)

Author:

mattausch

Message:

added measurement for pvs entries size decrease during subdivision

File:

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

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

@@ -616 +616 @@
 void VspTree::CreateViewCell(VspTraversalData &tData, const bool updatePvs)
 {
+        ///////////////
         //-- create new view cell
-        VspLeaf *leaf = dynamic_cast<VspLeaf *>(tData.mNode);
+        VspLeaf *leaf = tData.mNode;
         
         VspViewCell *viewCell = new VspViewCell();
@@ -627 +628 @@
         if (updatePvs)
         {
-                //-- update pvs of view cell
+                // update pvs of view cell
                 AddSamplesToPvs(leaf, *tData.mRays, sampCon, conSamp);
 
@@ -642 +643 @@
                 ///////////
                 //-- store sampling rays
-                RayInfoContainer::const_iterator it, it_end = tData.mRays->end();
+        RayInfoContainer::const_iterator it, it_end = tData.mRays->end();
 
                 for (it = tData.mRays->begin(); it != it_end; ++ it)
                 {
                         (*it).mRay->Ref();                      
+                        // note: should rather store rays with view cell
                         leaf->mVssRays.push_back((*it).mRay);
                 }
@@ -689 +691 @@
                 // create new interior node and two leaf node
                 const AxisAlignedPlane splitPlane = sc->mSplitPlane;
-                const int maxCostMisses = sc->mMaxCostMisses;
+                const int maxCostMisses = sc->GetMaxCostMisses();
 
                 newNode = SubdivideNode(splitPlane, tData, tFrontData, tBackData);
@@ -788 +790 @@
 
         // max cost threshold violated?
-        splitCandidate.mMaxCostMisses = maxCostRatioViolated  ? 
+        splitCandidate.SetMaxCostMisses(maxCostRatioViolated  ? 
                         splitCandidate.mParentData.mMaxCostMisses + 1:
-                        splitCandidate.mParentData.mMaxCostMisses;
+                        splitCandidate.mParentData.mMaxCostMisses);
         
         float oldRenderCost;
@@ -800 +802 @@
 
         splitCandidate.SetRenderCostDecrease(renderCostDecr);
+
+        // the increase in pvs entries num induced by this split
+        const int pvsEntriesIncr = EvalPvsEntriesIncr(splitCandidate);
+        splitCandidate.SetPvsEntriesIncr(pvsEntriesIncr);
 
 #if 0
@@ -814 +820 @@
 
 
+int VspTree::EvalPvsEntriesIncr(VspSubdivisionCandidate &splitCandidate) const
+{
+        float oldPvsSize = 0;
+        float fPvsSize = 0;
+        float bPvsSize = 0;
+        
+        AxisAlignedPlane candidatePlane = splitCandidate.mSplitPlane;
+        RayInfoContainer::const_iterator rit, 
+                rit_end = splitCandidate.mParentData.mRays->end();
+
+        // this is the main ray classification loop!
+        for(rit = splitCandidate.mParentData.mRays->begin(); rit != rit_end; ++ rit)
+        {
+                VssRay *ray = (*rit).mRay;
+                RayInfo rayInf = *rit;
+                
+                float t;
+                // classify ray
+                const int cf = 
+                        rayInf.ComputeRayIntersection(candidatePlane.mAxis, 
+                                                                                  candidatePlane.mPosition, t);
+
+                UpdatePvsEntriesContribution(*ray, true, cf, fPvsSize, bPvsSize, oldPvsSize);
+        }
+        
+        return (int)(fPvsSize + bPvsSize - oldPvsSize);
+}
+
+
 VspInterior *VspTree::SubdivideNode(const AxisAlignedPlane &splitPlane,
                                                                         VspTraversalData &tData,
@@ -836 +871 @@
                           *backData.mRays);
 
-        /////////////
         //-- compute pvs
         frontData.mPvs = EvalPvsSize(*frontData.mRays);
         backData.mPvs = EvalPvsSize(*backData.mRays);
-        //Debug << "f pvs: " << frontData.mPvs << " b pvs: " << backData.mPvs << " pvs " << tData.mPvs << endl;
-        
+                
         //-- split front and back node geometry and compute area
         tData.mBoundingBox.Split(splitPlane.mAxis, 
@@ -851 +884 @@
         backData.mProbability = tData.mProbability - frontData.mProbability;
 
-        // update some stats
-        // store maximal depth
+
+        ////////
+        //-- update some stats
+        
         if (tData.mDepth > mVspStats.maxDepth)
-        {
-                //Debug << "max depth increases to " << tData.mDepth << " at " << mVspStats.Leaves() << " leaves" << endl;
+        {       //Debug << "max depth increases to " << tData.mDepth << " at " << mVspStats.Leaves() << " leaves" << endl;
                 mVspStats.maxDepth = tData.mDepth;
         }
 
-        // two more leaves
+        // two more leaves per split
         mVspStats.nodes += 2;
         /// and a new split
@@ -865 +899 @@
 
 
-    ///////////////////////
+        ////////////////
         //-- create front and back and subdivide further
 
@@ -902 +936 @@
         CreateViewCell(frontData, false);
         CreateViewCell(backData, false);
-
 
 #if WORK_WITH_VIEWCELL_PVS
@@ -1436 +1469 @@
         // mark objects in the front / back / both using mailboxing
         // then count pvs sizes
+
         Intersectable::NewMail(3);
         KdLeaf::NewMail(3);
@@ -1497 +1531 @@
                   << "render cost decrease: " << renderCostDecrease << endl;
 #endif
+
         return renderCostDecrease;
 }
@@ -1519 +1554 @@
 
         const int pvsSize = data.mPvs;
-
         RayInfoContainer::const_iterator rit, rit_end = data.mRays->end();
 
@@ -1535 +1569 @@
         }
 
-
+        //////////////
         //-- evaluate cost heuristics
-
         float pOverall = data.mProbability;
 
@@ -1555 +1588 @@
 
 
-void VspTree::UpdateContributionsToPvs(Intersectable *obj,
-                                                                           const int cf,
-                                                                           float &frontPvs,
-                                                                           float &backPvs,
-                                                                           float &totalPvs) const
-{
-        if (!obj) return;
-
-        //const float renderCost = mViewCellsManager->SimpleRay &raynderCost(obj);
-        const int renderCost = 1;
-
-        // object in no pvs => new
-        if (!obj->Mailed() && !obj->Mailed(1) && !obj->Mailed(2))
-        {
-                totalPvs += renderCost;
-        }
-
-        // QUESTION matt: is it safe to assume that 
-        // the object belongs to no pvs in this case?
-        //if (cf == Ray::COINCIDENT) return;
-
-        if (cf >= 0) // front pvs
-        {
-                if (!obj->Mailed() && !obj->Mailed(2))
-                {
-                        frontPvs += renderCost;
-                
-                        // already in back pvs => in both pvss
-                        if (obj->Mailed(1))
-                                obj->Mail(2);
-                        else
-                                obj->Mail();
-                }
-        }
-
-        if (cf <= 0) // back pvs
-        {
-                if (!obj->Mailed(1) && !obj->Mailed(2))
-                {
-                        backPvs += renderCost;
-                
-                        // already in front pvs => in both pvss
-                        if (obj->Mailed())
-                                obj->Mail(2);
-                        else
-                                obj->Mail(1);
-                }
-        }
-}
-
-
 void VspTree::UpdateContributionsToPvs(BvhLeaf *leaf,
                                                                            const int cf,
                                                                            float &frontPvs,
                                                                            float &backPvs,
-                                                                           float &totalPvs) const
+                                                                           float &totalPvs,
+                                                                           const bool countEntries) const
 {
         if (!leaf) return;
-
-        const int renderCost = (int)leaf->mObjects.size();
+        const int renderCost = countEntries ? 1 : (int)leaf->mObjects.size();
 
         // leaf in no pvs => new
@@ -1621 +1603 @@
                 totalPvs += renderCost;
         }
-
-        // QUESTION matt: is it safe to assume that 
-        // the leaf belongs to no pvs in this case?
-        //if (cf == Ray::COINCIDENT) return;
 
         if (cf >= 0) // front pvs
@@ -1684 +1662 @@
     }   
         
-        // QUESTION matt: is it safe to assume that 
-        // the object belongs to no pvs in this case?
-        //if (cf == Ray::COINCIDENT) return;
-
         if (cf >= 0) // front pvs
         {
@@ -2146 +2120 @@
 
 
+int VspTree::EvalPvsEntriesContribution(const VssRay &ray, 
+                                                                                const bool isTermination) const
+
+{
+                Intersectable *obj; 
+                Vector3 pt;
+                KdNode *node;
+
+                ray.GetSampleData(isTermination, pt, &obj, &node);
+                if (!obj) return 0;
+
+                switch(mHierarchyManager->GetObjectSpaceSubdivisionType())
+                {
+                case HierarchyManager::NO_OBJ_SUBDIV:
+                {
+                        if (!obj->Mailed())
+                        {
+                                obj->Mail();
+                                return 1;
+                        }
+                        
+                        return 0;
+                }
+
+                case HierarchyManager::KD_BASED_OBJ_SUBDIV:
+                {
+                        KdLeaf *leaf = mHierarchyManager->mOspTree->GetLeaf(pt, node);
+                        if (!leaf->Mailed())
+                        {
+                                leaf->Mail();
+                                return 1;
+                        }
+                        
+                        return 0;
+                }
+        case HierarchyManager::BV_BASED_OBJ_SUBDIV:
+                {
+                        BvhLeaf *bvhleaf = mHierarchyManager->mBvHierarchy->GetLeaf(obj);
+
+                        if (!bvhleaf->Mailed())
+                        {
+                                bvhleaf->Mail();
+                                return 1;
+                        }
+                        
+                        return 0;
+                }
+        default:
+                break;
+        }
+
+        return 0;
+}
+
+
+int VspTree::EvalPvsEntriesSize(const RayInfoContainer &rays) const
+{
+        int pvsSize = 0;
+
+        Intersectable::NewMail();
+        KdNode::NewMail();
+        BvhLeaf::NewMail();
+
+        RayInfoContainer::const_iterator rit, rit_end = rays.end();
+
+        for (rit = rays.begin(); rit != rays.end(); ++ rit)
+        {
+                VssRay *ray = (*rit).mRay;
+
+                pvsSize += EvalPvsEntriesContribution(*ray, true);
+                pvsSize += EvalPvsEntriesContribution(*ray, false);
+        }
+
+        return pvsSize;
+}
+
+
 float VspTree::GetEpsilon() const
 {
@@ -2991 +3042 @@
 
 
-int VspTree::EvalContributionToPvs(const VssRay &ray, 
-                                                                   const bool isTermination) const
+void VspTree::UpdatePvsEntriesContribution(const VssRay &ray,
+                                                                                   const bool isTermination,
+                                                                                   const int cf,
+                                                                                   float &frontPvs,
+                                                                                   float &backPvs,
+                                                                                   float &totalPvs) const
+{
+        /*ray.GetSampleData(isTermination, pt, &obj, &node);
+        if (!obj) return 0;
+
+        switch (mHierarchyManager->GetObjectSpaceSubdivisionType())
+        {
+        case HierarchyManager::KD_BASED_OBJ_SUBDIV:
+                // TODO
+                break;
+        case HierarchyManager::BV_BASED_OBJ_SUBDIV:
+                {
+                        BvhLeaf *leaf = mHierarchyManager->mBvHierarchy->GetLeaf(obj);
+                        UpdateContributionsToPvs(leaf, true, cf, pvsFront, pvsBack, totalPvs, true);            
+                        break;
+                }
+        default:
+                UpdateContributionsToPvs(obj, true, cf, pvsFront, pvsBack, totalPvs, true);     
+                break;
+        }*/
+}
+
+
+int VspTree::EvalContributionToPvs(const VssRay &ray, const bool isTermination) const
 {       
         Intersectable *obj; 
@@ -3018 +3096 @@
                 {
                         KdLeaf *leaf = mHierarchyManager->mOspTree->GetLeaf(pt, node);
-
                         pvs += EvalContributionToPvs(leaf);
                         break;
@@ -3048 +3125 @@
         leaf->Mail();
 
+        // this is the pvs which is uniquely part of this kd leaf
         int pvs = (int)(leaf->mObjects.size() - leaf->mMultipleObjects.size());