Changeset 1666 for GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

Timestamp:

10/23/06 15:37:18 (18 years ago)

Author:

mattausch

Message:

working on render cost evaluation framework for interleaved splits

File:

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

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

@@ -5512 +5512 @@
         {
                 ViewCell *viewcell = *it;
-                
+
                 if (viewcell->GetValid())
                 {       // if ray not outside of view space
@@ -5519 +5519 @@
                         if (ray.mTerminationObject) 
                         {
-                          // todo: maybe not correct for kd node pvs
-                          Intersectable *obj = mHierarchyManager->GetIntersectable(ray, true);
-                          
-                          if (viewcell->GetPvs().GetSampleContribution(obj,
-                                                                                                                   ray.mPdf, 
-                                                                                                                   contribution))
+                                // todo: maybe not correct for kd node pvs
+                                Intersectable *obj = mHierarchyManager->GetIntersectable(ray, true);
+
+                                if (viewcell->GetPvs().GetSampleContribution(obj,
+                                        ray.mPdf, 
+                                        contribution))
                                 {
-                                  ++ ray.mPvsContribution;
+                                        ++ ray.mPvsContribution;
                                 }
-                          
-                          ray.mRelativePvsContribution += contribution;
+
+                                ray.mRelativePvsContribution += contribution;
                         }
-                        
-                        // for directional sampling it is important to count only contributions
-                        // made in one direction!
-                        // the other contributions of this sample will be counted for the opposite ray!
+
+                        //-- for directional sampling it is important to count only contributions 
+                        //-- made in one direction!
+                        //-- the other contributions of this sample will be counted for the opposite ray!
 #if SAMPLE_ORIGIN_OBJECTS
                         if (ray.mOriginObject && 
                                 viewcell->GetPvs().GetSampleContribution(ray.mOriginObject,
-                                                                                                                 ray.mPdf,
-                                                                                                                 contribution))
+                                ray.mPdf,
+                                contribution))
                         {
                                 ++ ray.mPvsContribution;
@@ -5616 +5616 @@
 
 
+typedef priority_queue<ViewCell *, vector<ViewCell *>, 
+                                           myless<vector<ViewCell *>::value_type> > ViewCellsQueue;
+
+typedef priority_queue<BvhNode *, vector<BvhNode *>, 
+                                           myless<vector<BvhNode *>::value_type> > ObjectsQueue;
+
+void VspOspViewCellsManager::ExportStats(const string &mergeStats)
+{
+        ofstream stats;
+        stats.open(mergeStats.c_str());
+
+        ObjectsQueue objectsQueue;
+        ViewCellsQueue viewCellsQueue;
+
+        objectsQueue.push(mHierarchyManager->mBvHierarchy->GetRoot());
+        viewCellsQueue.push(mViewCellsTree->GetRoot());
+        
+        int numViewCells = 1;
+        
+        const AxisAlignedBox3 box = mViewSpaceBox;
+        const float vol = box.GetVolume();
+
+        const int rootPvs = mViewCellsTree->GetPvsSize(mViewCellsTree->GetRoot());
+        const int rootEntries = mViewCellsTree->GetPvsEntries(mViewCellsTree->GetRoot());
+
+        cout << "exporting stats ... " << endl;
+        
+        float totalRenderCost, avgRenderCost, expectedCost;
+
+        float deviation = 0;
+        int totalPvs = rootPvs;
+        int entriesInPvs = rootEntries;
+
+        totalRenderCost = avgRenderCost = expectedCost = (float)rootPvs;
+
+        const float entrySize = sizeof(PvsData) + sizeof(Intersectable *);
+        const float memoryCost = (float)entriesInPvs *  entrySize / (1024.0f * 1024.0f);
+
+        /////////////
+        //-- first view cell
+
+/*      mViewCellsTree->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 (!(objectsQueue.empty() && viewCellsQueue.empty()))
+        {
+                ViewCell *viewCell = viewCellsQueue.top();
+                BvhNode *bvhNode =  objectsQueue.top();
+
+                if (viewCell->GetMergeCost() < bvhNode->GetMergeCost())
+                {
+                        viewCellsQueue.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 entrySize = sizeof(PvsData) + sizeof(Intersectable *);
+                                const float memoryCost = (float)entriesInPvs * entrySize / (1024.0f * 1024.0f);
+
+                                mViewCellsTree->UpdateStats(stats,
+                                                                                        0, 
+                                                                                        numViewCells, 
+                                                                                        costDecr, 
+                                                                                        totalRenderCost,
+                                                                                        parentPvs, 
+                                                                                        expectedCost, 
+                                                                                        avgRenderCost, 
+                                                                                        deviation,
+                                                                                        totalPvs, 
+                                                                                        entriesInPvs, 
+                                                                                        memoryCost,
+                                                                                        childPvs - parentPvs,
+                                                                                        vc->GetVolume());
+                                */
+                        }
+                        else // object space split
+                        {
+                        }
+        }
+
+        stats.close();
+}
+
+
 #if TEST_EVALUATION
 void VspOspViewCellsManager::EvalViewCellPartition()
@@ -5693 +5833 @@
         cout << "finished" << endl;
 
-        vector<int> storageFunc;
-        mViewCellsTree->GetStorageFunction(storageFunc);
-
-        vector<float> costFunc;
-        mViewCellsTree->GetCostFunction(costFunc);
-
-        ofstream outstr("out.txt");
-
-        for (int i = 0; i < storageFunc.size(); ++ i)
-                outstr << i << ": " << storageFunc[i] << endl;
-outstr << endl;
-        for (int i = 0; i < costFunc.size(); ++ i)
-                outstr << i << ": " << costFunc[i] << endl;
-        if (0)
-        for (int i = 0; i <50; ++ i)
-        {
-                Vector3 point = GetViewSpaceBox().GetRandomPoint();
-                ViewCell *vc = GetViewCell(point);
-        }
-        //RenderBvhNode(mHierarchyManager->mBvHierarchy->GetRoot());
-
         disposeRays(evaluationSamples, NULL);
 }