Changeset 1603 for GTP

Timestamp:

10/10/06 16:42:52 (18 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/Lib/Vis/Preprocessing/src

Files:

• ViewCell.cpp (modified) (8 diffs)
• ViewCell.h (modified) (2 diffs)
• ViewCellsManager.cpp (modified) (5 diffs)
• ViewCellsManager.h (modified) (3 diffs)
• VspBspTree.cpp (modified) (10 diffs)

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

@@ -621 +621 @@
                         const int numMergedViewCells = UpdateActiveViewCells(activeViewCells);
                 
-                        
-                        //-- resets / refines the view cells
+                        /////////////////
+                        //-- reset / refine the view cells
                         //-- priorities are recomputed
                         //-- the candidates are put back into merge queue
+
                         if (mRefineViewCells)
                                 RefineViewCells(rays, objects);
@@ -687 +688 @@
 
                         // check if "siblings (back and front node of the same parent)
-                        if (0 && mViewCellsManager->EqualToSpatialNode(mergedVc))
+                        if (0)
                                 ++ mergeStats.siblings;
                         // set the coŽst for rendering a view cell
@@ -1531 +1532 @@
 
         Debug << "******** Export stats **********" << endl;
-        /*Debug << "vsb volume: " << vol << endl;
-        Debug << "root volume: " << mRoot->GetVolume() << endl;
-        Debug << "root pvs: " << rootPvs << endl;
-        */
-
+        
         float totalRenderCost, avgRenderCost, expectedCost;
 
@@ -1547 +1544 @@
         stats.open(mergeStats.c_str());
 
+        /////////////
         //-- first view cell
+
         UpdateStats(stats,
                                 0, numViewCells, 0, totalRenderCost, 
@@ -1595 +1594 @@
                         }
 
-
+                        // update stats for this view cell
                         const float costDecr = (parentCost - childCost) / vol;
 
@@ -2171 +2170 @@
 /** Get costs resulting from each merge step. 
 */
-void
-ViewCellsTree::GetCostFunction(vector<float> &costFunction)
-{
-  TraversalQueue tqueue;
-  tqueue.push(mRoot);
-  
-  while (!tqueue.empty()) 
-        {
-          ViewCell *vc = 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 (!vc->IsLeaf()) {  
-                ViewCellInterior *interior = dynamic_cast<ViewCellInterior *>(vc);
-                costFunction.push_back(interior->GetMergeCost());
+void ViewCellsTree::GetCostFunction(vector<float> &costFunction)
+{
+        TraversalQueue tqueue;
+        tqueue.push(mRoot);
+
+        int numViewCells = 1;
+
+        const float vol = mViewCellsManager->GetViewSpaceBox().GetVolume();
+        const int rootPvs = GetPvsSize(mRoot);
+        
+        float totalRenderCost;
+
+        int totalPvs = rootPvs;
+        totalRenderCost = (float)rootPvs;
+
+        costFunction.push_back(totalRenderCost);
+
+        //-- 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 float parentCost = (float)parentPvs * interior->GetVolume();
+
+                        -- numViewCells;
+
+                        float childCost = 0;
+                        int childPvs = 0;
+                        
+                        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);
+                                
+                                childCost += (float) pvsSize * vc->GetVolume();
+                                childPvs += pvsSize;
+                                
+                                tqueue.push(vc);
+                                ++ numViewCells;
+                        }
+
+                        // update stats for this view cell
+                        const float costDecr = (parentCost - childCost) / vol;
+                        totalRenderCost -= costDecr;
+                        const float expectedCost = totalRenderCost ;/// (float)numViewCells;
                 
-                ViewCellContainer::const_iterator it, it_end = interior->mChildren.end();
-                
-                for (it = interior->mChildren.begin(); it != it_end; ++ it) {
-                  tqueue.push(*it);
-                }
-                
-          }
-        }
-}
+                        costFunction.push_back(expectedCost);
+                }
+        }
+}
+
+
+/** Get storage costs resulting from each merge step. 
+*/
+void ViewCellsTree::GetStorageFunction(vector<int> &storageFunction)
+{
+        TraversalQueue tqueue;
+        tqueue.push(mRoot);
+
+        int numViewCells = 1;
+
+        const float vol = mViewCellsManager->GetViewSpaceBox().GetVolume();
+        const int rootEntries = GetPvsEntries(mRoot);
+
+        int entriesInPvs = rootEntries;
+    const int entryStorage = 1;//sizeof(PvsData) + sizeof(int); // one entry into the pvs
+
+        storageFunction.push_back(rootEntries);
+
+        ////////////
+        //-- 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);
+
+                                //childPvs += pvsSize;
+                                childPvsEntries += pvsEntries;
+
+                                tqueue.push(vc);
+                                ++ numViewCells;
+                        }
+
+                        // update stats for this view cell
+                        const float costDecr = (parentCost - childCost) / vol;
+
+                        //totalPvs += childPvs - parentPvs;
+                        entriesInPvs += childPvsEntries - parentPvsEntries;
+
+                        const int storageCost = entriesInPvs * entryStorage;
+                        storageFunction.push_back(storageCost);
+                }
+        }
+}
+
 
 
@@ -2358 +2467 @@
 }
 
+
+
 /**************************************************************************/
 /*                     MergeCandidate implementation                      */
@@ -2438 +2549 @@
 
 
-
 /************************************************************************/
 /*                    MergeStatistics implementation                    */

GTP/trunk/Lib/Vis/Preprocessing/src/ViewCell.h

@@ -416 +416 @@
         */
         void GetCostFunction(vector<float> &costFunction);
-  
+        
+        /** Returns storage cost resulting from each merge step.
+        */
+        void GetStorageFunction(vector<int> &storageCost);
+
         /** Returns optimal set of view cells for a given number of view cells.
         */
@@ -504 +508 @@
         void SetViewCellsManager(ViewCellsManager *vcm);
 
+        void Update();
 
 protected:

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

@@ -258 +258 @@
 
 
-bool ViewCellsManager::EqualToSpatialNode(ViewCell *viewCell) const 
-{ 
-        return false;
-}
-
-
 int ViewCellsManager::CastPassSamples(const int samplesPerPass, 
                                                                           const int sampleType, 
@@ -851 +845 @@
 
         // should directional sampling be used?
-        bool dirSamples = (mEvaluationSamplingType == SamplingStrategy::DIRECTION_BASED_DISTRIBUTION);
+        bool dirSamples = 
+                (mEvaluationSamplingType == SamplingStrategy::DIRECTION_BASED_DISTRIBUTION);
 
         cout << "reseting pvs ... ";
@@ -914 +909 @@
                 cout << "compute new statistics ... " << endl;
         
-                ///////////////7
+                ///////////////
                 //-- propagate pvs or pvs size information
 
@@ -3948 +3943 @@
 
         mColorCode = savedColorCode;
-
-}
-
-
-bool VspBspViewCellsManager::EqualToSpatialNode(ViewCell *viewCell) const
-{
-        return GetSpatialNode(viewCell) != NULL;
-}
-
-
-BspNode *VspBspViewCellsManager::GetSpatialNode(ViewCell *viewCell) const
-{
-        if (!viewCell->IsLeaf())
-        {
-                BspViewCell *bspVc = dynamic_cast<BspViewCell *>(viewCell);
-                return bspVc->mLeaves[0];
-        }
-        else
-        {
-                ViewCellInterior *interior = dynamic_cast<ViewCellInterior *>(viewCell);
-
-                // cannot be node of binary tree
-                if (interior->mChildren.size() != 2)
-                        return NULL;
-
-                ViewCell *left = interior->mChildren[0];
-                ViewCell *right = interior->mChildren[1];
-
-                BspNode *leftNode = GetSpatialNode(left);
-                BspNode *rightNode = GetSpatialNode(right);
-
-                if (leftNode && rightNode && leftNode->IsSibling(rightNode))
-                {
-                        return leftNode->GetParent(); 
-                }
-        }
-
-        return NULL;
 }
 
@@ -5713 +5670 @@
         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)

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

@@ -479 +479 @@
         //////////////////////////////////////////////////////////////////
 
-
-        /** Returns true if the view cell is equivalent to a 
-                node of the spatial hierarchy. This function can be used for merged
-                view cell.
-                e.g. to see if the spatial tree can be reduced on this location
-                note: not implemented
-        */
-        virtual bool EqualToSpatialNode(ViewCell *viewCell) const;
-
         /** If true, the kd nodes are stored instead of the object pvs.
         */
@@ -966 +957 @@
         void CollectMergeCandidates(const VssRayContainer &rays, vector<MergeCandidate> &candidates);
 
-        /** Returns true if this view cell is equivavalent to a spatial node.
-        */
-        bool EqualToSpatialNode(ViewCell *viewCell) const;
-
-
         void ExportSingleViewCells(
                 const ObjectContainer &objects,
@@ -986 +972 @@
         int ComputeBoxIntersections(const AxisAlignedBox3 &box, ViewCellContainer &viewCells) const;
         
-        /** Returns node of the spatial hierarchy corresponding to the view cell
-                if such a node exists.
-        */
-        BspNode *GetSpatialNode(ViewCell *viewCell) const;
-
         /** Merges view cells according to some criteria
         */

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

@@ -17 +17 @@
 #include "ViewCellsManager.h"
 #include "Beam.h"
+#include "IntersectableWrapper.h"
 
 
@@ -243 +244 @@
                                                                   MeshInstance *parent)
 {
+        if (!mesh)
+                return 0;
+
         FaceContainer::const_iterator fi;
 
@@ -260 +264 @@
                 }
         }
+
         return (int)mesh->mFaces.size();
 }
@@ -268 +273 @@
                                                                  int maxObjects)
 {
-        int limit = (maxObjects > 0) ?
+        const int limit = (maxObjects > 0) ?
                 Min((int)viewCells.size(), maxObjects) : (int)viewCells.size();
 
@@ -277 +282 @@
                 Mesh *mesh = viewCells[i]->GetMesh();
                 if (mesh) 
-                {       // // copy the mesh into polygons and add to BSP tree aabb
+                {       // copy the mesh into polygons and add to BSP tree aabb
                         mBoundingBox.Include(viewCells[i]->GetBox()); 
                         polysSize += AddMeshToPolygons(mesh,
@@ -293 +298 @@
                                                                  int maxObjects)
 {
-        int limit = (maxObjects > 0) ?
+        const int limit = (maxObjects > 0) ?
                 Min((int)objects.size(), maxObjects) : (int)objects.size();
 
@@ -305 +310 @@
                 case Intersectable::MESH_INSTANCE:
                         mesh = dynamic_cast<MeshInstance *>(object)->GetMesh();
+                        AddMeshToPolygons(mesh, polys, NULL);
                         break;
                 case Intersectable::VIEW_CELL:
                         mesh = dynamic_cast<ViewCell *>(object)->GetMesh();
+                        AddMeshToPolygons(mesh, polys, NULL);
                         break;
                 case Intersectable::TRANSFORMED_MESH_INSTANCE:
                         {
-                                TransformedMeshInstance *mi = dynamic_cast<TransformedMeshInstance *>(object);
-
-                                if (!mi->GetMesh())     
-                                        break;
-                                mesh = new Mesh();
-                                mi->GetTransformedMesh(*mesh);
-                                
+                                TransformedMeshInstance *mi = 
+                                        dynamic_cast<TransformedMeshInstance *>(object);
+
+                                Mesh mesh;
+                                mi->GetTransformedMesh(mesh);
+                                AddMeshToPolygons(&mesh, polys, NULL);
                 break;
                         }
+                case Intersectable::TRIANGLE_INTERSECTABLE:
+                        {
+                                TriangleIntersectable *intersect = 
+                                        dynamic_cast<TriangleIntersectable *>(object);
+
+                                Polygon3 *poly = new Polygon3(intersect->GetItem());
+
+                                if (poly->Valid(mEpsilon))      
+                                        polys.push_back(poly);
+                                else
+                                        delete poly;
+                        }
                 default:
-                        Debug << "intersectable type not supported" << endl;
+                                Debug << "intersectable type not supported" << endl;
                         break;
                 }
 
-        if (mesh) // copy the mesh data to polygons
-                {
-                        mBoundingBox.Include(object->GetBox()); // add to BSP tree aabb
-                        AddMeshToPolygons(mesh, polys, NULL);
-
-                        // cleanup
-                        if (object->Type() == Intersectable::TRANSFORMED_MESH_INSTANCE)
-                                DEL_PTR(mesh);
-                }
+                mBoundingBox.Include(object->GetBox()); // add to BSP tree aabb
         }
 
@@ -413 +423 @@
                                                 }
                                                 break;
+
                                         case Intersectable::MESH_INSTANCE:
                                                 {
@@ -419 +430 @@
                                                 }
                                                 break;
+
                                         case Intersectable::TRIANGLE_INTERSECTABLE:
                                                 {
-                                                        // TODO
-                                                        cout << "not implemented yet" << endl;
+                                                        TriangleIntersectable *intersect = 
+                                                                        dynamic_cast<TriangleIntersectable *>(obj);
+
+                                                        Polygon3 *poly = new Polygon3(intersect->GetItem());
+
+                                                        if (poly->Valid(mEpsilon))      
+                                                                polys.push_back(poly);
+                                                        else
+                                                                delete poly;
                                                 }
+                                                break;
+
                                         default:
+                                                cout << "not implemented yet" << endl;
                                                 break;
                                 }
@@ -430 +452 @@
                                 ++ numObj;
 
+                                /////////
                                 //-- compute bounding box
+
                                 if (!forcedBoundingBox)
+                                {
                                         mBoundingBox.Include(ray->mTermination);
+                                }
                         }