Changeset 382 for trunk/VUT/GtpVisibilityPreprocessor/src/VssTree.h

Timestamp:

11/05/05 20:03:25 (19 years ago)

Author:

bittner

Message:

vsspreprocessor update

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/VssTree.h (modified) (14 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/VssTree.h

@@ -43 +43 @@
   // totals number of rays
   int rays;
-  // total number of query domains
+        // initial size of the pvs
+  int initialPvsSize;
+        // total number of query domains
   int queryDomains;
   // total number of ray references
   int rayRefs;
-  // refs in non empty leafs
-  int rayRefsNonZeroQuery;
-  // total number of query references
-  int queryDomainRefs;
-  // nodes with zero queries
-  int zeroQueryNodes;
-  // max depth nodes
+
+        // max depth nodes
   int maxDepthNodes;
   // max depth nodes
   int minCostNodes;
+        // max ray contribution nodes
+  int maxRayContribNodes;
+        // max depth nodes
+  int minSizeNodes;
+        
   // max number of rays per node
   int maxRayRefs;
@@ -78 +80 @@
       splits[i] = 0;
     rays = queryDomains = 0;
-    rayRefs = rayRefsNonZeroQuery = queryDomainRefs = 0;
-    zeroQueryNodes = 0;
+    rayRefs = 0;
     maxDepthNodes = 0;
     minCostNodes = 0;
     maxRayRefs = 0;
     addedRayRefs = removedRayRefs = 0;
+                initialPvsSize = 0;
+                maxRayContribNodes = 0;
+                minSizeNodes = 0;
   }
 
@@ -101 +105 @@
 // For sorting rays
 // --------------------------------------------------------------
-struct  SSortableEntry
+struct  SortableEntry
 {
   enum EType {
@@ -112 +116 @@
   void *data;
   
-  SSortableEntry() {}
-  SSortableEntry(const int t, const float v, void *d):type(t),
-                                                                                                                                                                                                                        value(v),
-                                                      data(d) {}
-        
-  friend bool operator<(const SSortableEntry &a, const SSortableEntry &b) {
+  SortableEntry() {}
+  SortableEntry(const int t, const float v, void *d):type(t),
+                                                                                                                                                                                                                 value(v),
+                                                                                                                                                                                                                 data(d) {}
+        
+  friend bool operator<(const SortableEntry &a, const SortableEntry &b) {
     return a.value < b.value;
   }
@@ -215 +219 @@
         void SetMaxT (const float t) { mMaxT = t; }
 #endif 
+
+
+  int ComputeRayIntersection(const float axis,
+                                                                                                                 const float position,
+                                                                                                                 float &t
+                                                                                                                 ) const {
+                
+                // intersect the ray with the plane
+    float denom = mRay->GetDir(axis);
+    
+    if (fabs(denom) < 1e-20)
+      //if (denom == 0.0f)
+      return (mRay->GetOrigin(axis) > position) ? 1 : -1;
+    
+    t = (position - mRay->GetOrigin(axis))/denom;
+
+    if (t < GetMinT())
+      return (denom > 0) ? 1 : -1;
+
+    if (t > GetMaxT())
+      return (denom > 0) ? -1 : 1;
+
+                return 0;
+        }
+
+
 };
 
@@ -329 +359 @@
 
   
+        
   int ComputeRayIntersection(const RayInfo &rayData,
                                                                                                                  float &t
                                                                                                                  ) {
-                
-    // intersect the ray with the plane
-    float denom = rayData.mRay->GetDir(axis);
-    
-    if (fabs(denom) < 1e-20)
-      //if (denom == 0.0f)
-      return (rayData.mRay->GetOrigin(axis) > position) ? 1 : -1;
-    
-    t = (position - rayData.mRay->GetOrigin(axis))/denom;
-
-    if (t < rayData.GetMinT())
-      return (denom > 0) ? 1 : -1;
-
-    if (t > rayData.GetMaxT())
-      return (denom > 0) ? -1 : 1;
-    
-    return 0;
+                return rayData.ComputeRayIntersection(axis, position, t);
   }
 
@@ -365 +380 @@
   
   RayInfoContainer rays;
-
-  
-  VssTreeLeaf(VssTreeInterior *p, const int n):VssTreeNode(p), rays() {
-    rays.reserve(n);
+        int mPvsSize;
+  
+  VssTreeLeaf(VssTreeInterior *p,
+                                                        const int nRays
+                                                        ):VssTreeNode(p), rays(), mPvsSize(0) {
+    rays.reserve(nRays);
   }
   
@@ -392 +409 @@
   }
 
+        float GetAvgRayContribution() const {
+                return mPvsSize/(float)rays.size();
+        }
 };
 
@@ -490 +510 @@
   // max depth of the tree
   int termMaxDepth;
-  // minimal cost of the node to still get subdivided
-  int termMinCost;
   // minimal ratio of the volume of the cell and the query volume
   float termMinSize;
 
-  // minimal cost imporvement to subdivide a node
-  float maxCostRatio;
-  
+        // minimal pvs per node to still get subdivided
+  int termMinPvs;
+
+  // maximal cost ration to subdivide a node
+  float termMaxCostRatio;
+        
+        // maximal contribution per ray to subdivide the node
+        float termMaxRayContribution;
+
+        
   // randomized construction
   bool randomize;
 
   // type of the splitting to use fo rthe tree construction
-  enum {ESplitRegular, ESplitVolume, ESplitQueries };
+  enum {ESplitRegular, ESplitVolume };
   int splitType;
         
@@ -528 +553 @@
   
   // reusable array of split candidates
-  vector<SSortableEntry> *splitCandidates;
+  vector<SortableEntry> *splitCandidates;
   /////////////////////////////
 
@@ -540 +565 @@
   Construct(
                                                 VssRayContainer &rays,
-                                                const bool onlyStaticPart
+                                                AxisAlignedBox3 *forcedBoundingBox = NULL
                                                 );
         
@@ -565 +590 @@
   int
   SelectPlane(VssTreeLeaf *leaf,
-              const AxisAlignedBox3 &box,
-              float &position
-              );
+                                                        const AxisAlignedBox3 &box,
+                                                        float &position,
+                                                        int &raysBack,
+                                                        int &raysFront,
+                                                        int &pvsBack,
+                                                        int &pvsFront
+                                                        );
 
   void
@@ -590 +619 @@
   }
   
+        float
+        BestCostRatio(
+                                                                VssTreeLeaf *node,
+                                                                int &axis,
+                                                                float &position,
+                                                                int &raysBack,
+                                                                int &raysFront
+                                                                );
+        
+        float
+        EvalCostRatio(
+                                                                VssTreeLeaf *node,
+                                                                const int axis,
+                                                                const float position,
+                                                                int &raysBack,
+                                                                int &raysFront,
+                                                                int &pvsBack,
+                                                                int &pvsFront
+                                                                );
 
   AxisAlignedBox3 GetBBox(const VssTreeNode *node) {
@@ -664 +712 @@
   EvaluateLeafStats(const TraversalData &data);
 
+        void
+        EvalLeafPvs(VssTreeLeaf *leaf);
+
+        
 };