Changeset 407 for trunk/VUT

Timestamp:

11/13/05 22:38:46 (19 years ago)

Author:

mattausch

Message:

 

Location:

trunk/VUT

Files:

• GtpVisibilityPreprocessor/src/KdTree.h (modified) (1 diff)
• GtpVisibilityPreprocessor/src/RenderSimulator.cpp (modified) (4 diffs)
• GtpVisibilityPreprocessor/src/RenderSimulator.h (modified) (2 diffs)
• GtpVisibilityPreprocessor/src/SamplingPreprocessor.cpp (modified) (2 diffs)
• GtpVisibilityPreprocessor/src/ViewCellBsp.cpp (modified) (2 diffs)
• GtpVisibilityPreprocessor/src/ViewCellBsp.h (modified) (1 diff)
• scripts/GtpVisibility.suo (modified) (previous)

trunk/VUT/GtpVisibilityPreprocessor/src/KdTree.h

@@ -178 +178 @@
   /** \sa KdNode::IsLeaf() */
   virtual bool IsLeaf() const { return true; }
-  
-
-  
+
 
   /** pointers to occluders contained in this node */

trunk/VUT/GtpVisibilityPreprocessor/src/RenderSimulator.cpp

@@ -27 +27 @@
         Real renderTime = 0;
 
-        // render time for 1 object of PVS
-        const float objRt = mObjRenderCost; 
-         // const overhead for crossing a view cell border
-        const float vcOverhead = mVcOverhead;
-        
         // total area of view cells
         float totalArea = 0;//= mKdTree->GetBox().SurfaceArea();
@@ -40 +35 @@
 
         ViewCellContainer::const_iterator it, it_end = viewCells.end();
-        
+
+        // surface area substitute for probability
+        PolygonContainer cell;
+
         for (it = viewCells.begin(); it != it_end; ++ it)
         {
-                // surface area substitute for probability
-                PolygonContainer cell;
-                float area = 0;
-
                 mBspTree->ConstructGeometry(dynamic_cast<BspViewCell *>(*it), cell);
-
-                area = Polygon3::GetArea(cell);
+                CLEAR_CONTAINER(cell);
+                float area = Polygon3::GetArea(cell);
                 
-                renderTime += area * RenderPvs(*(*it), objRt) + vcOverhead;
+                renderTime += area * (RenderPvs(*(*it), mObjRenderCost) + mVcOverhead);
                 totalArea += area;
-                CLEAR_CONTAINER(cell);
         }
 
@@ -64 +57 @@
 }
 
-Real BspTreeRenderSimulator::RenderPvs(ViewCell &viewCell, float objRenderTime) const
+Real BspTreeRenderSimulator::RenderPvs(ViewCell &viewCell, 
+                                                                           float objRenderTime) const
 {
         return viewCell.GetPvs().GetSize() * objRenderTime;
 }
 
-/*****************************************************
- *     class KdLeafRenderSimulator implementation    *
- *****************************************************/
+/********************************************************
+ *     class KdLeafRenderSimulator implementation       *
+ *******************************************************/
 
 KdTreeRenderSimulator::KdTreeRenderSimulator(float objRenderCost, 
@@ -82 +76 @@
 Real KdTreeRenderSimulator::SimulateRendering()
 {
+        //mKdTree->CollectLeavesPvs();
+
+        // total render time
         Real renderTime = 0;
+        // overhead for loading a view cell
+        float loadOverhead = 0;
 
-        // total area of view cells
-        float totalArea = 0;//= mKdTree->GetBox().SurfaceArea();
+        // probability that view point lies in a view cell
+        float pInVcTotal = 0;//mKdTree->GetBox().GetVolume();
 
-        return renderTime;
+        // total probability that a view cell border is crossed
+        float pCrossVcTotal = 0;
+
+        vector<KdLeaf *> leaves;
+        mKdTree->CollectLeaves(leaves);
+        
+        AxisAlignedBox3 box;
+
+        vector<KdLeaf *>::const_iterator it, it_end = leaves.end();
+        
+        for (it = leaves.begin(); it != it_end; ++ it)
+        {
+                box = mKdTree->GetBox(*it);
+                        
+                // volume substitute for view point probability
+                float pInVc = 0;
+                
+                if (0)
+                        pInVc = box.GetVolume(); 
+                else
+                        pInVc = box.SurfaceArea();
+                
+                // probability that a view cell border is crossed
+                const float pCrossVc = box.SurfaceArea();
+
+                renderTime += pInVc * RenderPvs(*it, mObjRenderCost);
+                loadOverhead += pCrossVc * mVcOverhead;
+
+                pInVcTotal += pInVc;
+                pCrossVcTotal += pCrossVc;
+        }
+
+        renderTime /= pInVcTotal;
+        loadOverhead /= pCrossVcTotal;
+
+        return renderTime + loadOverhead;
 }
+
+Real KdTreeRenderSimulator::RenderPvs(KdLeaf *leaf, 
+                                                                                   float objRenderTime) const
+{
+        return leaf->mKdPvs.GetSize() * objRenderTime;
+}

trunk/VUT/GtpVisibilityPreprocessor/src/RenderSimulator.h

@@ -7 +7 @@
 class KdTree;
 class ViewCell;
-
+class KdLeaf;
 
 /** Simulated rendering using a simple render heuristics. Used to evaluate the 
@@ -47 +47 @@
 public:
         KdTreeRenderSimulator(float objRenderCost, float vcOverhead, KdTree *kdTree);
-
         Real SimulateRendering();
 
 protected:
+
+        Real RenderPvs(KdLeaf *leaf, float objRenderTime) const;
+
         KdTree *mKdTree;
 };

trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.cpp

@@ -537 +537 @@
         
         if (ViewCell::sHierarchy == ViewCell::KD)       
-                cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
+                cout << "#totalKdPvsSize=" << mKdTree->CollectLeafPvs() << endl;
   
         if (mBspTree)
         {
                 //-- render simulation
-                cout << "\nevaluating render time before merge ... ";
+                cout << "\nevaluating bsp view cells render time before merge ... ";
                 Real rt = BspTreeRenderSimulator(mObjRenderCost, mVcOverhead, mBspTree).SimulateRendering();
                 
@@ -652 +652 @@
         if (1) {
         
+        if (ViewCell::sHierarchy == ViewCell::KD)
+        {
+                cout << "\nevaluating kd view cells render time ... ";
+                Real rt = KdTreeRenderSimulator(mObjRenderCost, mVcOverhead, mKdTree).SimulateRendering();
+                
+                cout << "avg render time: " << rt * 1e-3 << endl;
+                Debug << "avg render time: " << rt * 1e-3 << endl;
+        }
+
    for (int k=0; k < pvsOut; k++) {
                  Intersectable *object = objects[k];

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -48 +48 @@
 float BspTree::sPvsFactor = 1.0f;
 
+bool BspTree::sStoreLeavesWithRays = false;
 int BspNode::mailID = 1;
 
@@ -284 +285 @@
                         ++ contributingSamples;
                 }
-                // warning: intersections not ordered
-                ray->bspIntersections.push_back(Ray::BspIntersection((*it)->mMinT, this));
+                if (BspTree::sStoreLeavesWithRays)
+                        // warning: intersections not ordered
+                        ray->bspIntersections.push_back(Ray::BspIntersection((*it)->mMinT, this));
         }
 }

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.h

@@ -794 +794 @@
         static int sTermMaxObjectsForAxisAligned;
 
+        static bool sStoreLeavesWithRays;
+
         /// axis aligned split criteria
         static float sCt_div_ci;