Changeset 397 for trunk/VUT

Timestamp:

11/09/05 18:23:43 (19 years ago)

Author:

mattausch

Message:

worked on bsp view cells, fixed some bugs

Location:

trunk/VUT/GtpVisibilityPreprocessor

Files:

• scripts/default.env (modified) (1 diff)
• src/Environment.cpp (modified) (1 diff)
• src/ViewCellBsp.cpp (modified) (15 diffs)
• src/ViewCellBsp.h (modified) (2 diffs)

trunk/VUT/GtpVisibilityPreprocessor/scripts/default.env

@@ -126 +126 @@
         #splitPlaneStrategy 130
         
-        splitPlaneStrategy 8
+        splitPlaneStrategy 1024
         
-        maxPolyCandidates 50
-        maxRayCandidates 1024
+        maxPolyCandidates 200
+        maxRayCandidates 0
         
         Termination {
                 # autopartition
-                maxRays 100
-                maxPolygons 0
-                maxDepth 50
-                minPvs -1
+                maxRays 200
+                maxPolygons 5
+                maxDepth 30
+                minPvs 50
+                minArea -0.001
                 
                 # axis aligned splits

trunk/VUT/GtpVisibilityPreprocessor/src/Environment.cpp

@@ -1220 +1220 @@
                  "20");
 
+  RegisterOption("BspTree.Termination.minArea",
+                 optFloat,
+                 "-bsp_term_min_area=",
+                 "0.001");
+
    RegisterOption("BspTree.Termination.maxRays",
                  optInt,

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -17 +17 @@
 int BspTree::sTermMinPvs = 20;
 int BspTree::sTermMaxDepth = 20;
+float BspTree::sTermMinArea = 0.001;
 int BspTree::sMaxPolyCandidates = 10;
 int BspTree::sMaxRayCandidates = 10;
@@ -692 +693 @@
 }
 
+inline bool BspTree::TerminationCriteriaMet(const BspTraversalData &data) const
+{
+        return 
+                (((int)data.mPolygons->size() <= sTermMaxPolygons) || 
+                 ((int)data.mRays->size() <= sTermMaxRays) ||
+                 (data.mPvs <= sTermMinPvs) ||
+                 (data.mArea <= sTermMinArea) ||
+                 (data.mDepth >= sTermMaxDepth));
+}
 
 BspNode *BspTree::Subdivide(BspTraversalStack &tStack, BspTraversalData &tData)
 {
         //-- terminate traversal  
-        if (((int)tData.mPolygons->size() <= sTermMaxPolygons) || 
-                ((int)tData.mRays->size() <= sTermMaxRays) ||
-                (tData.mPvs <= sTermMinPvs) ||
-                 (tData.mDepth >= sTermMaxDepth))
-                
+        if (TerminationCriteriaMet(tData))              
         {
                 BspLeaf *leaf = dynamic_cast<BspLeaf *>(tData.mNode);
@@ -747 +753 @@
 
         //-- continue subdivision
-
         PolygonContainer coincident;
         
@@ -1053 +1058 @@
         if (sSplitPlaneStrategy & RANDOM_POLYGON)
         {
-                Polygon3 *nextPoly = (*data.mPolygons)[Random((int)data.mPolygons->size())];
-                return nextPoly->GetSupportingPlane();
+                if (!data.mPolygons->empty())
+                {
+                        Polygon3 *nextPoly = (*data.mPolygons)[Random((int)data.mPolygons->size())];
+                        return nextPoly->GetSupportingPlane();
+                }
+                
+                return Plane3();
         }
 
@@ -1083 +1093 @@
                         SplitPlaneCost(poly->GetSupportingPlane(), data, frontData, backData);
 
-                Debug << "cost: " << candidateCost << ", lowest: " << lowestCost << endl;
-
                 if (candidateCost < lowestCost)
                 {
@@ -1092 +1100 @@
         }
         
+        Debug << "lowest: " << lowestCost << endl;
+
         //limit = maxRaysCandidates > 0 ? Min((int)rays.size(), maxRayCandidates) : (int)rays.size();   
         const BoundedRayContainer *rays = data.mRays;
@@ -1103 +1113 @@
                         Vector3 pt[3];
                         int idx[3];
-                        
+                
                         for (int j = 0; j < 3; j ++)
                         {
                                 idx[j] = Random((int)rays->size() * 2);
                                 
-                                BoundedRay *bRay = (*rays)[idx[j]];
-                                Ray *ray = bRay->mRay;
-
                                 if (idx[j] < (int)rays->size())
-                                        pt[j] = ray->Extrap(bRay->mMinT);
+                                        pt[j] = (*rays)[idx[j]]->mRay->Extrap((*rays)[idx[j]]->mMinT);
                                 else
-                                {
+                                {       
                                         idx[j] -= (int)rays->size();
-                                        pt[j] = ray->Extrap(bRay->mMaxT);
+                                        pt[j] = (*rays)[idx[j]]->mRay->Extrap((*rays)[idx[j]]->mMaxT);
                                 }
                         }       
-                
+                        
                         plane = Plane3(pt[0], pt[1], pt[2]);
                 }
@@ -1144 +1151 @@
                 if (candidateCost < lowestCost)
                 {
-                        Debug << "choose ray plane: " << lowestCost << endl;
+                        Debug << "choose ray plane: " << candidateCost << endl;
                         bestPlane = plane;
                         
                         lowestCost = candidateCost;
                 }
-                else
-                        Debug << "ray cost: " << candidateCost << ", lowest: " << lowestCost << endl;
-        }
-
-        //Debug << "Plane lowest cost: " << lowestCost << endl;
+        }
+
+        Debug << "Plane lowest cost: " << lowestCost << endl;
         return bestPlane;
 }
@@ -1262 +1267 @@
         // all values should be approx. between 0 and 1 so they can be combined
         // and scaled with the factors according to their importance
-        if (sSplitPlaneStrategy & BALANCED_POLYS)
+        if ((sSplitPlaneStrategy & BALANCED_POLYS) && (!polys.empty()))
                 val += sBalancedPolysFactor * fabs(sumBalancedPolys) / (float)polys.size();
         
-        if (sSplitPlaneStrategy & LEAST_SPLITS)    
+        if ((sSplitPlaneStrategy & LEAST_SPLITS) && (!polys.empty()))  
                 val += sLeastSplitsFactor * sumSplits / (float)polys.size();
 
@@ -1411 +1416 @@
         if ((sSplitPlaneStrategy & BALANCED_RAYS) && !rays.empty())
                         val += sBalancedRaysFactor * fabs(sumBalancedRays) / (float)rays.size();
-
+pOverall = 1; pFront = 1; pBack = 1;
         if ((sSplitPlaneStrategy & PVS) && area && pvs)
                 val += sPvsFactor * (frontData.mPvs * pFront + (backData.mPvs * pBack)) /
@@ -1543 +1548 @@
         environment->GetIntValue("BspTree.Termination.maxPolygons", sTermMaxPolygons);
         environment->GetIntValue("BspTree.Termination.maxRays", sTermMaxRays);
+        environment->GetFloatValue("BspTree.Termination.minArea", sTermMinArea);
 
         //-- termination criteria for axis aligned split
@@ -1569 +1575 @@
     Debug << "BSP max depth: " << sTermMaxDepth << endl;
         Debug << "BSP min PVS: " << sTermMinPvs << endl;
+        Debug << "BSP min area: " << sTermMinArea << endl;
         Debug << "BSP max polys: " << sTermMaxPolygons << endl;
         Debug << "BSP max rays: " << sTermMaxRays << endl;
@@ -1652 +1659 @@
 
         // store minimal and maximal pvs
-        /*if (data.mPvs > mStat.pvs)
-                mStat.pvs = data.mPvs;
-        
-        if (data.mPvs < mStat.pvs)
-                mStat.pvs = data.mPvs;*/
+        /*if (data.mPvs > mStat.pvs)mStat.pvs = data.mPvs;
+        if (data.mPvs < mStat.pvs)      mStat.pvs = data.mPvs;*/
 
         // accumulate depth to compute average
@@ -1664 +1668 @@
         Debug << "BSP stats: "
                   << "Depth: " << data.mDepth << " (max: " << sTermMaxDepth << "), "
-                   << "PVS: " << data.mPvs << " (max: " << sTermMinPvs << "), "
+                  << "PVS: " << data.mPvs << " (min: " << sTermMinPvs << "), "
+                  << "Area: " << data.mArea << " (min: " << sTermMinArea << "), "
                   << "#polygons: " << (int)data.mPolygons->size() << " (max: " << sTermMaxPolygons << "), "
                   << "#rays: " << (int)data.mRays->size() << " (max: " << sTermMaxRays << "), " 
@@ -2392 +2397 @@
         }
 
-        //Debug << "returning new geometry " << mPolys.size() << " CHILD: " << childCell->mPolys.size() << endl;
-        //Debug << "old area " << this->GetArea() << " new: " << childCell->GetArea() << endl;
+        Debug << "returning new geometry " << mPolys.size() << " f: " << front.mPolys.size() << " b: " << back.mPolys.size() << endl;
+        Debug << "old area " << GetArea() << " f: " << front.GetArea() << " b: " << back.GetArea() << endl;
 }
 

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.h

@@ -740 +740 @@
         int ComputePvsSize(const BoundedRayContainer &rays) const;
 
+        bool TerminationCriteriaMet(const BspTraversalData &data) const;
+
         /// Pointer to the root of the tree
         BspNode *mRoot;
@@ -782 +784 @@
         /// maximal possible depth
         static int sTermMaxDepth;
-        /// mininam pvs
+        /// mininum area
+        static float sTermMinArea;
+        /// mininum PVS
         static int sTermMinPvs;
         /// strategy to get the best split plane