Changeset 1706 for GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.cpp

Timestamp:

11/01/06 18:36:21 (18 years ago)

Author:

mattausch

Message:

worked on full evaluation framework

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.cpp (modified) (2 diffs)

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

@@ -1600 +1600 @@
 }
 
-/*typedef priority_queue<ViewCell *, vector<ViewCell *>, 
-                                           myless<vector<ViewCell *>::value_type> > ViewCellsQueue;
-
-typedef priority_queue<BvhNode *, vector<BvhNode *>, 
-                                           myless<vector<BvhNode *>::value_type> > BvhQueue;
-
-typedef priority_queue<VspNode *, vector<VspNode *>, 
-                                           myless<vector<VspNode *>::value_type> > VspQueue;
-*/
+
 static void UpdateStats(ofstream &stats,
                                                 const int splits,
@@ -1776 +1768 @@
 }
 
-        
-}
+
+
+class HierarchyNodeWrapper;
+
+
+template <typename T> class myless
+{
+public:
+        bool operator() (T v1, T v2) const
+        {
+                return (v1->GetMergeCost() < v2->GetMergeCost());
+        }
+};
+
+typedef priority_queue<HierarchyNodeWrapper *, vector<HierarchyNodeWrapper *>, 
+                                           myless<vector<HierarchyNodeWrapper *>::value_type> > HierarchyNodeQueue;
+
+class HierarchyNodeWrapper
+{
+public:
+        enum {VSP_NODE, BVH_NODE};
+
+        virtual float GetMergeCost() const = 0;
+        virtual int Type() const  = 0;
+        virtual bool IsLeaf() const = 0;
+
+        virtual void PushChildren(HierarchyNodeQueue &tQueue) = 0;
+};
+
+
+class VspNodeWrapper: public HierarchyNodeWrapper
+{
+public:
+        VspNodeWrapper(VspNode *node): mNode(node) {}
+
+        int Type() const { return VSP_NODE; }
+
+        float GetMergeCost() const { return (float) -mNode->mTimeStamp; };
+
+        bool IsLeaf() const { return mNode->IsLeaf(); }
+
+        void PushChildren(HierarchyNodeQueue &tQueue)
+        {
+                if (!mNode->IsLeaf())
+                {
+                        VspInterior *interior = dynamic_cast<VspInterior *>(mNode);
+
+                        tQueue.push(new VspNodeWrapper(interior->GetFront()));
+                        tQueue.push(new VspNodeWrapper(interior->GetBack()));
+                }
+        }
+
+        VspNode *mNode;
+};
+
+
+class BvhNodeWrapper: public HierarchyNodeWrapper
+{
+public:
+        BvhNodeWrapper(BvhNode *node): mNode(node) {}
+        
+        int Type()  const { return BVH_NODE; }
+
+        float GetMergeCost() const { return (float)-mNode->mTimeStamp; };
+
+        bool IsLeaf() const { return mNode->IsLeaf(); }
+
+        void PushChildren(HierarchyNodeQueue &tQueue)
+        {
+                if (!mNode->IsLeaf())
+                {
+                        BvhInterior *interior = dynamic_cast<BvhInterior *>(mNode);
+
+                        tQueue.push(new BvhNodeWrapper(interior->GetFront()));
+                        tQueue.push(new BvhNodeWrapper(interior->GetBack()));
+                }
+        }
+
+        BvhNode *mNode;
+};
+
+
+void HierarchyManager::CollectBestSet(const int maxSplits,
+                                                                          const float maxMemoryCost,
+                                                                          vector<VspNode *> &vspNodes,
+                                                                          vector<BvhNode *> &bvhNodes)
+{
+        HierarchyNodeQueue tqueue;
+        tqueue.push(new VspNodeWrapper(mVspTree->GetRoot()));
+        tqueue.push(new BvhNodeWrapper(mBvHierarchy->GetRoot()));
+        
+        float memCost = 0;
+
+        while (!tqueue.empty())
+        {
+                HierarchyNodeWrapper *nodeWrapper = tqueue.top();
+                tqueue.pop();
+
+                // save the view cells if it is a leaf or if enough view cells have already been traversed
+                // because of the priority queue, this will be the optimal set of v
+                if (nodeWrapper->IsLeaf() || 
+                        ((vspNodes.size() + bvhNodes.size() + tqueue.size() + 1) >= maxSplits) ||
+                        (memCost > maxMemoryCost)
+                        )
+                {
+                        if (nodeWrapper->Type() == HierarchyNodeWrapper::VSP_NODE)
+                        {
+                                VspNodeWrapper *vspNodeWrapper = dynamic_cast<VspNodeWrapper *>(nodeWrapper);
+                                vspNodes.push_back(vspNodeWrapper->mNode);
+                        }
+                        else
+                        {
+                                BvhNodeWrapper *bvhNodeWrapper = dynamic_cast<BvhNodeWrapper *>(nodeWrapper);
+                                bvhNodes.push_back(bvhNodeWrapper->mNode);
+                        }
+                }
+                else 
+                {       
+                        nodeWrapper->PushChildren(tqueue);
+                }
+
+                delete nodeWrapper;
+        }
+}
+
+
+void HierarchyManager::ExtractStatistics(const int maxSplits,
+                                                                                 const float maxMemoryCost,
+                                                                                 float &renderCost,
+                                                                                 float &memory,
+                                                                                 int &pvsEntries)
+{
+        /*TraversalQueue tqueue;
+        tqueue.push(mRoot);
+
+        //cout << "exporting stats ... " << endl;
+        int numViewCells = 1;
+        
+        const AxisAlignedBox3 box = mViewCellsManager->GetViewSpaceBox();
+        const float vol = box.GetVolume();
+
+        const int rootPvs = GetPvsSize(mRoot);
+        const int rootEntries = GetPvsEntries(mRoot);
+        float totalRenderCost, avgRenderCost, expectedCost;
+
+        float deviation = 0;
+        int totalPvs = rootPvs;
+        int entriesInPvs = rootEntries;
+
+        totalRenderCost = avgRenderCost = expectedCost = (float)rootPvs;
+
+        ofstream stats;
+        stats.open(mergeStats.c_str());
+
+        const float memoryCost = (float)entriesInPvs * ObjectPvs::GetEntrySize();
+
+        /////////////
+        //-- first view cell
+
+        UpdateStats(stats,
+                                0, 
+                                numViewCells, 
+                                0, 
+                                totalRenderCost, 
+                                rootPvs, 
+                                expectedCost, 
+                                avgRenderCost, 
+                                deviation,
+                                totalPvs, 
+                                entriesInPvs,
+                                memoryCost,
+                                0, 
+                                mRoot->GetVolume());
+                
+
+        //-- go through tree in the order of render cost decrease
+        //-- which is the same order as the view cells were merged
+        //-- or the reverse order of subdivision for subdivision-only 
+        //-- view cell hierarchies.
+
+        while (!tqueue.empty())
+        {
+                ViewCell *vc = tqueue.top();
+                tqueue.pop();
+
+                if (!vc->IsLeaf()) 
+                {       
+                        ViewCellInterior *interior = dynamic_cast<ViewCellInterior *>(vc);
+
+                        const int parentPvs = GetPvsSize(interior);
+                        const int parentPvsEntries = GetPvsEntries(interior);
+            const float parentCost = (float)parentPvs * interior->GetVolume();
+
+                        float childCost = 0;
+                        int childPvs = 0;
+                        int childPvsEntries = 0;
+
+                        -- numViewCells;
+
+                        ViewCellContainer::const_iterator it, it_end = interior->mChildren.end();
+
+                        for (it = interior->mChildren.begin(); it != it_end; ++ it)
+                        {
+                                ViewCell *vc = *it;
+
+                                const int pvsSize = GetPvsSize(vc);
+                                const int pvsEntries = GetPvsEntries(vc);
+
+                                childCost += (float) pvsSize * vc->GetVolume();
+                                childPvs += pvsSize;
+                                childPvsEntries += pvsEntries;
+
+                                tqueue.push(vc);
+                                ++ numViewCells;
+                        }
+
+                        // update stats for this view cell
+                        const float costDecr = (parentCost - childCost) / vol;
+
+                        totalRenderCost -= costDecr;
+                        totalPvs += childPvs - parentPvs;
+                        entriesInPvs += childPvsEntries - parentPvsEntries;
+
+                        expectedCost = totalRenderCost / (float)numViewCells;
+                        avgRenderCost = (float)totalPvs / (float)numViewCells;
+
+                        const float memoryCost = (float)entriesInPvs * ObjectPvs::GetEntrySize();
+
+                        UpdateStats(stats,
+                                                0, 
+                                                numViewCells, 
+                                                costDecr, 
+                                                totalRenderCost,
+                                                parentPvs, 
+                                                expectedCost, 
+                                                avgRenderCost, 
+                                                deviation,
+                        totalPvs, 
+                                                entriesInPvs, 
+                                                memoryCost,
+                                                childPvs - parentPvs,
+                                                vc->GetVolume());
+                }
+        }
+
+        stats.close();
+        */
+}
+        
+}