Changeset 383 for trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

Timestamp:

11/06/05 01:24:55 (19 years ago)

Author:

mattausch

Message:

 

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp (modified) (14 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -1084 +1084 @@
         if (sSplitPlaneStrategy & RANDOM_POLYGON)
         {
-                Vector3 pt[3];
-                for (int j = 0; j < 3; j ++)
-                {
-                        int idx = Random((int)rays.size());
-                        pt[j] = rays[idx]->mRay->Extrap(rays[idx]->mMaxT);
-                }
-
-                return Plane3(pt[0], pt[1], pt[2]);
-
-        //return polys[Random((int)polys.size())]->GetSupportingPlane();
+                return polys[Random((int)polys.size())]->GetSupportingPlane();
         }
 
         // use heuristics to find appropriate plane
-        return SelectPlaneHeuristics(polys, rays, sMaxPolyCandidates, sMaxRayCandidates);
-}
-
-Plane3 BspTree::SelectPlaneHeuristics(PolygonContainer &polys,
+        return SelectPlaneHeuristics(leaf, 
+                                         polys, 
+                                                                 rays, 
+                                                                 sMaxPolyCandidates, 
+                                                                 sMaxRayCandidates);
+}
+
+Plane3 BspTree::SelectPlaneHeuristics(BspLeaf *leaf,
+                                                                          PolygonContainer &polys,
                                                                           const BoundedRayContainer &rays,
                                                                           const int maxPolyCandidates,
@@ -1108 +1104 @@
         int bestPlaneIdx = 0;
         
-        int limit = maxPolyCandidates > 0 ? Min((int)polys.size(), maxPolyCandidates) : (int)polys.size();
+        int limit = maxPolyCandidates > 0 ? 
+                Min((int)polys.size(), maxPolyCandidates) : (int)polys.size();
         
         int candidateIdx = limit;
 
-        //Debug << endl;
-        /*for (int i = 0; i < limit; ++ i)
+        for (int i = 0; i < limit; ++ i)
         {
                 candidateIdx = GetNextCandidateIdx(candidateIdx, polys);
-
-                Plane3 candidatePlane = polys[candidateIdx]->GetSupportingPlane();
+                
+                // evaluate current candidate
+                const float candidateCost = 
+                        SplitPlaneCost(leaf,
+                                       polys[candidateIdx]->GetSupportingPlane(), 
+                                                   polys, rays);
+
                 //Debug << polys[candidateIdx] << endl;
-                // evaluate current candidate
-                float candidateCost = SplitPlaneCost(candidatePlane, polys, rays);
-                        
                 if (candidateCost < lowestCost)
                 {
@@ -1127 +1125 @@
                         lowestCost = candidateCost;
                 }
-        }*/
+        }
         
         //limit = maxRaysCandidates > 0 ? Min((int)rays.size(), maxRayCandidates) : (int)rays.size();
@@ -1140 +1138 @@
                 for (int j = 0; j < 3; j ++)
                 {
-                        idx[j] = Random((int)rays.size());
-                        pt[j] = rays[idx[j]]->mRay->Extrap(rays[idx[j]]->mMaxT);
-                }
-
-                float candidateCost = SplitPlaneCost(Plane3(pt[0], pt[1], pt[2]), polys, rays);
+                        idx[j] = Random((int)rays.size() * 2);
+                                
+                        if (idx[j] < (int)rays.size())
+                                pt[j] = rays[idx[j]]->mRay->Extrap(rays[idx[j]]->mMinT);
+                        else
+                        {
+                                idx[j] -= (int)rays.size();
+                                pt[j] = rays[idx[j]]->mRay->Extrap(rays[idx[j]]->mMaxT);
+                        }
+                                        
+                }
+
+                const float candidateCost =
+                        SplitPlaneCost(leaf, Plane3(pt[0], pt[1], pt[2]), 
+                                                   polys, rays);
 
                 if (candidateCost < lowestCost)
@@ -1157 +1165 @@
         if (chooseFromRays)
         {
+                Debug << "choose ray plane: " << lowestCost << endl;
                 return Plane3(rays[bestIdx[0]]->mRay->Extrap(rays[bestIdx[0]]->mMaxT),
                                           rays[bestIdx[1]]->mRay->Extrap(rays[bestIdx[1]]->mMaxT),
@@ -1177 +1186 @@
 }
 
-float BspTree::SplitPlaneCost(const Plane3 &candidatePlane, 
+float BspTree::SplitPlaneCost(BspLeaf *leaf, 
+                                                          const Plane3 &candidatePlane, 
                                                           const PolygonContainer &polys) const
 {
@@ -1316 +1326 @@
 }
 
-float BspTree::SplitPlaneCost(const Plane3 &candidatePlane, 
+float BspTree::SplitPlaneCost(BspLeaf *leaf,
+                                                          const Plane3 &candidatePlane, 
                                                           const BoundedRayContainer &rays) const
 {
@@ -1333 +1344 @@
         Intersectable::NewMail(); const int frontAndBackId = ViewCell::sMailId;
 
-        /*PolygonContainer cell;
+        PolygonContainer cell;
         PolygonContainer front;
         PolygonContainer back;
 
-        ConstructGeometry(currentNode, cell);
-        ConstructChildrenGeometry(front, cell, planes, sides);
-        ConstructChildrenGeometry(back, cell, planes, sides);*/
-
-
+        vector<Plane3 *> planes;
+        vector<bool> sides;
+
+        ExtractSplitPlanes(leaf, planes, sides);
+
+        ConstructGeometry(leaf, cell);
+        ConstructChildGeometry(front, cell, planes, sides, candidatePlane, true);
+        ConstructChildGeometry(back, cell, planes, sides, candidatePlane, false);
+
+        CLEAR_CONTAINER(cell);
+        CLEAR_CONTAINER(front);
+        CLEAR_CONTAINER(back);
+        
         int frontRays = 0;
         int backRays = 0;
@@ -1475 +1494 @@
 }
 
-float BspTree::SplitPlaneCost(const Plane3 &candidatePlane, 
+float BspTree::SplitPlaneCost(BspLeaf *leaf,
+                                                          const Plane3 &candidatePlane, 
                                                           const PolygonContainer &polys,                                                          
                                                           const BoundedRayContainer &rays) const
@@ -1497 +1517 @@
                 (sSplitPlaneStrategy & BLOCKED_RAYS))
         {
-        val += SplitPlaneCost(candidatePlane, polys);
+        val += SplitPlaneCost(leaf, candidatePlane, polys);
         }
 
@@ -1505 +1525 @@
                 (sSplitPlaneStrategy & PVS))
         {
-                val += SplitPlaneCost(candidatePlane, rays);
+                val += SplitPlaneCost(leaf, candidatePlane, rays);
         }
 
@@ -2019 +2039 @@
 }
 
-bool BspTree::ComputeChildrenGeometry(PolygonContainer &newCell,
-                                                                          const PolygonContainer &cell,
-                                                                          const vector<Plane3> &planes,
-                                                                          const vector<bool> &sides,
-                                                                          const Plane3 &splitPlane,
-                                                                          const bool side) const
+bool BspTree::ConstructChildGeometry(PolygonContainer &newCell,
+                                                                         const PolygonContainer &cell,
+                                                                         const vector<Plane3 *> &planes,
+                                                                         const vector<bool> &sides,
+                                                                         const Plane3 &splitPlane,
+                                                                         const bool side) const
 {
         // get cross section of new polygon
@@ -2034 +2054 @@
         for (int i = 0; (i < planes.size()) && inside; ++ i)
         {
-                const int cf = planePoly->ClassifyPlane(planes[i]);
+                const int cf = planePoly->ClassifyPlane(*planes[i]);
                         
                 // split new polygon with all previous planes
@@ -2046 +2066 @@
                                         Polygon3 *backPoly = new Polygon3();
 
-                                        planePoly->Split(planes[i], *frontPoly, *backPoly, splitPts);
+                                        planePoly->Split(*planes[i], *frontPoly, *backPoly, splitPts);
                                         DEL_PTR(planePoly);