Changeset 1233 for GTP/trunk/Lib/Vis/Preprocessing/src/Pvs.cpp

Timestamp:

08/20/06 22:48:01 (18 years ago)

Author:

mattausch

Message:

 

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/Pvs.cpp (modified) (4 diffs)

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

@@ -6 +6 @@
 #include "KdTree.h"
 #include "common.h"
+#include "BvHierarchy.h"
 
 
@@ -19 +20 @@
 }
 
+/** the pvs is the number of different objects in the node leaves
+        We eliminate already accounted kd nodes and objects using mailboxing. 
+*/
+static int CountNewObjectsInKdNode(KdIntersectable *kdobj)
+{
+        int pvs = 0;
+        stack<KdNode *> tStack;
+
+        tStack.push(kdobj->GetItem());
+
+        while (!tStack.empty())
+        {
+                KdNode *node = tStack.top();
+                tStack.pop();
+
+                // already processed node (=> objects already in pvs)?
+                if (!node->Mailed())
+                {
+                        node->Mail();
+
+                        if (node->IsLeaf())
+                        {
+                                KdLeaf *leaf = dynamic_cast<KdLeaf *>(node);
+                       
+                                // add #objects exclusivly in this node
+                                pvs += (int)(leaf->mObjects.size() - leaf->mMultipleObjects.size());
+
+                                // Objects already accounted for can only be found among those
+                                // which are referenced in more than one leaf
+                                ObjectContainer::const_iterator oit, oit_end = leaf->mMultipleObjects.end();
+                                                
+                                for (oit = leaf->mMultipleObjects.begin(); oit != oit_end; ++ oit)
+                                {
+                                        Intersectable *object = *oit;                                           
+                            
+                                        if (!object->Mailed())
+                                        {
+                                                object->Mail();
+                                                ++ pvs;
+                                        }
+                                }
+                        }
+                        else // traverse tree
+                        {
+                                KdInterior *interior = dynamic_cast<KdInterior *>(node);
+
+                                tStack.push(interior->mFront);
+                                tStack.push(interior->mBack);
+                        }
+                }
+        }
+
+        return pvs;
+}
+
+
+/** the pvs is the number of different objects in the node leaves
+        We eliminate already accounted kd nodes and objects using mailboxing. 
+*/
+static int CountNewObjectsInBvhNode(BvhIntersectable *bvhobj)
+{
+        BvhNode *node= bvhobj->GetItem();
+
+        // early exit
+        if (node->IsLeaf())     
+        {
+                if (!node->Mailed())
+                {
+                        node->Mail();
+                        return (int)(((BvhLeaf *)node)->mObjects.size());
+                }
+                else
+                {
+                        return 0;
+                }
+        }
+                                 
+
+        // compute leaf pvs
+        int pvs = 0;
+
+        stack<BvhNode *> tStack;
+
+        tStack.push(bvhobj->GetItem());
+
+        while (!tStack.empty())
+        {
+                BvhNode *node = tStack.top();
+                tStack.pop();
+
+                // already processed node (=> objects already in pvs)?
+                if (!node->Mailed())
+                {
+                        node->Mail();
+
+                        if (node->IsLeaf())
+                        {
+                                BvhLeaf *leaf = dynamic_cast<BvhLeaf *>(node);
+                       
+                                // add #objects exclusivly in this node
+                                pvs += leaf->mObjects.size();
+                        }
+                        else // traverse tree
+                        {
+                                BvhInterior *interior = dynamic_cast<BvhInterior *>(node);
+
+                                tStack.push(interior->GetFront());
+                                tStack.push(interior->GetBack());
+                        }
+                }
+        }
+        return pvs;
+}
+
+
 
 int ObjectPvs::CountObjectsInPvs() const
@@ -26 +142 @@
         Intersectable::NewMail();
         KdLeaf::NewMail();
+        BvhLeaf::NewMail();
 
         ObjectPvsMap::const_iterator it, it_end = mEntries.end();
@@ -33 +150 @@
                 Intersectable *obj = (*it).first;
 
-                // found kd node
-                // the pvs is the number od different objects in the node leaves
-                // We eliminate already accounted kd nodes and objects using mailboxing. 
-                if (obj->Type() == Intersectable::KD_INTERSECTABLE)
+                switch (obj->Type())
                 {
-                        KdIntersectable *kdObj = dynamic_cast<KdIntersectable *>(obj);
-
-                        stack<KdNode *> tStack;
-
-                        tStack.push(kdObj->GetNode());
-
-                        while (!tStack.empty())
-                        {
-                                KdNode *node = tStack.top();
-                                tStack.pop();
-
-                                // already processed node (= objects in pvs)?
-                                if (0 ||!node->Mailed())
+                        case Intersectable::KD_INTERSECTABLE:
                                 {
-                                        node->Mail();
-
-                                        if (node->IsLeaf())
-                                        {
-                                                KdLeaf *leaf = dynamic_cast<KdLeaf *>(node);
-#if 1                        
-                                                // add #objects exclusivly in this node
-                                                pvs += (int)(leaf->mObjects.size() - leaf->mMultipleObjects.size());
-
-                                                // Objects already accounted for can only be found among those
-                                                // which are referenced in more than one leaf
-                                                ObjectContainer::const_iterator oit, oit_end = leaf->mMultipleObjects.end();
-                                                
-                                                for (oit = leaf->mMultipleObjects.begin(); oit != oit_end; ++ oit)
-                                                {
-                                                        Intersectable *object = *oit;                                           
-                            
-                                                        if (!object->Mailed())
-                                                        {
-                                                                object->Mail();
-                                                                ++ pvs;
-                                                        }
-                                                }
-#else   
-                                                ObjectContainer::const_iterator oit, oit_end = leaf->mObjects.end();
-                                                
-                                                for (oit = leaf->mObjects.begin(); oit != oit_end; ++ oit)
-                                                {
-                                                        Intersectable *object = *oit;                                           
-                            
-                                                        if (!object->Mailed())
-                                                        {
-                                                                object->Mail();
-                                                                ++ pvs;
-                                                        }
-                                                }
-#endif
-                                        }
-                                        else // traverse tree
-                                        {
-                                                KdInterior *interior = dynamic_cast<KdInterior *>(node);
-
-                                                tStack.push(interior->mFront);
-                                                tStack.push(interior->mBack);
-                                        }
+                                        // found kd node
+                                        KdIntersectable *kdObj = dynamic_cast<KdIntersectable *>(obj);
+                                        pvs += CountNewObjectsInKdNode(kdObj);  
+                                        break;
                                 }
-                        }
-                }
-                else
-                {
-                        ++ pvs;
+                        case Intersectable::BVH_INTERSECTABLE:
+                                {
+                                        BvhIntersectable *bvhObj = dynamic_cast<BvhIntersectable *>(obj);
+                                        pvs += CountNewObjectsInBvhNode(bvhObj);
+                                        break;
+                                }
+                        default:
+                                ++ pvs;
+                                break;
                 }
         }