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

Timestamp:

10/12/05 01:15:22 (19 years ago)

Author:

mattausch

Message:

changed the from rays construction (not finished yet)

File:

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

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -16 +16 @@
 int BspTree::sTermMaxDepth = 20;
 int BspTree::sMaxCandidates = 10;
-int BspTree::sSplitPlaneStrategy = NEXT_POLYGON; 
+int BspTree::sSplitPlaneStrategy = BALANCED_POLYS; 
 int BspTree::sConstructionMethod = FROM_INPUT_VIEW_CELLS;
 int BspTree::sTermMaxPolysForAxisAligned = 50;
@@ -30 +30 @@
 float BspTree::sVerticalSplitsFactor = 1.0f; // very important criterium for 2.5d scenes
 float BspTree::sLargestPolyAreaFactor = 1.0f;
+float BspTree::sBlockedRaysFactor = 1.0f;
 
 /** Evaluates split plane classification with respect to the plane's 
@@ -552 +553 @@
 }
 
-void BspTree::Construct(const RayContainer &rays, ViewCellContainer *viewCells)
-{
-        // TODO
+void BspTree::Construct(const ObjectContainer &objects,
+                                                const RayContainer &rays, 
+                                                ViewCellContainer *viewCells)
+{
+        PolygonContainer *polys = new PolygonContainer();
+        
+        // copy mesh instance polygons into one big polygon soup
+        mStat.polys = AddToPolygonSoup(objects, *polys);
+
+        RayContainer::const_iterator rit, rit_end = rays.end();
+
+        long startTime = GetTime();
+        Debug << "**** Casting rays into polygons ****\n";
+
+        //-- cast rays into all polygons
+        for (rit = rays.begin(); rit != rays.end(); ++ rit)
+        {
+                Ray *ray = *rit;
+
+                PolygonContainer::const_iterator pit, pit_end = polys->end();
+                
+                for (pit = polys->begin(); pit != pit_end; ++ pit)
+                {
+                        Polygon3 *poly = *pit;
+                        
+                        float t = 0;
+                        float nearestT = 0;
+
+                        if (poly->CastRay(*ray, t, nearestT) > 0)
+                                poly->AddPiercingRay(ray);
+                }
+        }
+
+        Debug << "**** Finished ray casting ****\n";
+        Debug << "ray casting time: " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
+
+        Construct(polys, viewCells);
 }
 
@@ -565 +600 @@
 
         long startTime = GetTime();
-        Debug << "**** Contructing tree using objects ****\n";
+        Debug << "**** Contructing tree using scene geometry ****\n";
         while (!tStack.empty()) 
         {
@@ -607 +642 @@
                 leaf->SetViewCell(tData.mViewCell);
                 
-                //-- clean up
-
+                // clean up
                 // remaining polygons are discarded or added to node
                 leaf->ProcessPolygons(tData.mPolygons, mStoreSplitPolys);
                 DEL_PTR(tData.mPolygons);
-
-        CLEAR_CONTAINER(*tData.mRays);
-                DEL_PTR(tData.mRays);
 
                 return leaf;
@@ -629 +660 @@
                                                                                   *frontPolys,
                                                                                   *backPolys, 
-                                                                                  coincident,
-                                                                                  *tData.mRays);
+                                                                                  coincident);
 
         ViewCell *frontViewCell = mRootCell;
@@ -644 +674 @@
         // extract view cells from coincident polygons according to plane normal
     // only if front or back polygons are empty
-        ExtractViewCells(&backViewCell, 
-                                         &frontViewCell, 
-                                         coincident, 
-                                         interior->mPlane, 
+        ExtractViewCells(&backViewCell,
+                                         &frontViewCell,
+                                         coincident,
+                                         interior->mPlane,
                                          backPolys->empty(),
                                          frontPolys->empty());
@@ -653 +683 @@
         // don't need coincident polygons anymore
         interior->ProcessPolygons(&coincident, mStoreSplitPolys);
-
-        // split rays
-        RayContainer *frontRays = NULL;
-        RayContainer *backRays = NULL;
-
-        if (tData.mRays->size() > 0)
-        {
-                RayContainer *frontRays = new RayContainer();
-                RayContainer *backRays = new RayContainer();
-
-                Plane3 plane;
-                SplitRays(plane, *tData.mRays, *frontRays, *backRays);
-        }
 
         // push the children on the stack
@@ -671 +688 @@
                                                                  backPolys, 
                                                                  tData.mDepth + 1, 
-                                                                 backViewCell, 
-                                                                 backRays));
+                                                                 backViewCell));
 
         tStack.push(BspTraversalData(interior->GetFront(), 
                                                                  frontPolys, 
                                                                  tData.mDepth + 1, 
-                                                                 frontViewCell, 
-                                                                 frontRays));
+                                                                 frontViewCell));
 
         // cleanup
         DEL_PTR(tData.mNode);
         DEL_PTR(tData.mPolygons);
-        DEL_PTR(tData.mRays);
 
         return interior;
@@ -720 +734 @@
                                                                         PolygonContainer &frontPolys,
                                                                         PolygonContainer &backPolys, 
-                                                                        PolygonContainer &coincident,
-                                                                        const RayContainer &rays)
+                                                                        PolygonContainer &coincident)
 {
         mStat.nodes += 2;
 
         // add the new nodes to the tree + select subdivision plane
-        BspInterior *interior = new BspInterior(SelectPlane(leaf, polys, rays)); 
+        BspInterior *interior = new BspInterior(SelectPlane(leaf, polys)); 
 
 #ifdef _DEBUG
@@ -863 +876 @@
 
 Plane3 BspTree::SelectPlane(BspLeaf *leaf, 
-                                                        PolygonContainer &polys, 
-                                                        const RayContainer &rays)
+                                                        PolygonContainer &polys)
 {
         if (polys.size() == 0)
@@ -917 +929 @@
 
         // use heuristics to find appropriate plane
-        return SelectPlaneHeuristics(polys, rays, sMaxCandidates);
+        return SelectPlaneHeuristics(polys, sMaxCandidates);
 }
 
 Plane3 BspTree::SelectPlaneHeuristics(PolygonContainer &polys,
-                                                                          const RayContainer &rays,
                                                                           const int maxTests)
 {
@@ -938 +949 @@
                 
                 // evaluate current candidate
-                float candidateCost = EvalSplitPlane(polys, candidatePlane, rays);
+                float candidateCost = EvalSplitPlane(polys, candidatePlane);
                         
                 if (candidateCost < lowestCost)
@@ -966 +977 @@
 
 float BspTree::EvalSplitPlane(PolygonContainer &polys, 
-                                                          const Plane3 &candidatePlane, 
-                                                          const RayContainer &rays)
+                                                          const Plane3 &candidatePlane)
 {
         float val = 0;
@@ -980 +990 @@
         }
 
-        //-- strategies where the effect of the split plane on the polygons is tested
-        if (!((sSplitPlaneStrategy & BALANCED_POLYS) ||
-                  (sSplitPlaneStrategy & LEAST_SPLITS)   ||
-                  (sSplitPlaneStrategy & LARGEST_POLY_AREA) ||
-                  (sSplitPlaneStrategy & BALANCED_VIEW_CELLS)))
+        // strategies where the effect of the split plane is tested
+        // on all input polygons 
+        if (!((sSplitPlaneStrategy & BALANCED_POLYS)      ||
+                  (sSplitPlaneStrategy & LEAST_SPLITS)        ||
+                  (sSplitPlaneStrategy & LARGEST_POLY_AREA)   ||
+                  (sSplitPlaneStrategy & BALANCED_VIEW_CELLS) ||
+                  (sSplitPlaneStrategy & BLOCKED_RAYS)))
+        {
                 return val;
-        
-        PolygonContainer::const_iterator it, it_end = polys.end();
+        }
+
         float sumBalancedPolys = 0;
         float sumSplits = 0;
         float sumPolyArea = 0;
         float sumBalancedViewCells = 0;
+        float sumBlockedRays = 0;
+
+        float totalBlockedRays = 0;
         //float totalArea = 0;
 
-        // container for view cells
+        // container for balanced view cells criterium
         ObjectContainer frontViewCells;
         ObjectContainer backViewCells;
+
+        PolygonContainer::const_iterator it, it_end = polys.end();
 
         for (it = polys.begin(); it != it_end; ++ it)
@@ -1019 +1037 @@
                 }
 
+                
+                if (sSplitPlaneStrategy & BLOCKED_RAYS)
+                {
+                        float blockedRays = (float)(*it)->GetPiercingRays()->size();
+                        if (classification == Polygon3::COINCIDENT)
+                        {
+                                sumBlockedRays += blockedRays;
+                        }
+
+                        totalBlockedRays += blockedRays;
+                }
+
                 // assign view cells to back or front according to classificaion
                 if (sSplitPlaneStrategy & BALANCED_VIEW_CELLS)
@@ -1031 +1061 @@
         }
 
+        // 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)
                 val += sBalancedPolysFactor * fabs(sumBalancedPolys) / (float)polys.size();
@@ -1038 +1070 @@
 
         if (sSplitPlaneStrategy & LARGEST_POLY_AREA) 
-                val += sLargestPolyAreaFactor * (float)polys.size() / sumPolyArea; // HACK
+                // HACK (polys.size should be totalArea)
+                val += sLargestPolyAreaFactor * (float)polys.size() / sumPolyArea;
+
+        if (sSplitPlaneStrategy & BLOCKED_RAYS)
+                if (totalBlockedRays > 0)
+                        val += sBlockedRaysFactor * sumBlockedRays / totalBlockedRays;
 
         if (sSplitPlaneStrategy & BALANCED_VIEW_CELLS)
@@ -1133 +1170 @@
         if (sSplitPlaneStrategy & VERTICAL_AXIS)
                 Debug << "vertical axis ";
+        if (sSplitPlaneStrategy & BLOCKED_RAYS)
+                Debug << "blocked rays ";
 
         Debug << endl;
@@ -1357 +1396 @@
         }
 }
-
-void BspTree::SplitRays(const Plane3 plane,
-                                                RayContainer &rays, 
-                                                RayContainer &frontRays, 
-                                                RayContainer &backRays)
-{
-        while (!rays.empty())
-        {
-                //TODO
-        }
-}
 //} // GtpVisibilityPreprocessor