Changeset 551 for trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp

Timestamp:

01/18/06 23:35:50 (18 years ago)

Author:

mattausch

Message:

 

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp (modified) (19 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp

@@ -83 +83 @@
         // maximum and minimum number of view cells
         environment->GetIntValue("VspBspTree.Termination.maxViewCells", mMaxViewCells);
+
+        environment->GetBoolValue("VspBspTree.splitUseOnlyDrivingAxis", mOnlyDrivingAxis);
+
+        //-- merge options
         environment->GetIntValue("VspBspTree.PostProcess.minViewCells", mMergeMinViewCells);
         environment->GetFloatValue("VspBspTree.PostProcess.maxCostRatio", mMergeMaxCostRatio);
-
-        environment->GetBoolValue("VspBspTree.splitUseOnlyDrivingAxis", mOnlyDrivingAxis);
         environment->GetBoolValue("VspBspTree.PostProcess.useRaysForMerge", mUseRaysForMerge);
 
@@ -116 +118 @@
         Debug << "max plane candidates: " << mMaxRayCandidates << endl;
         Debug << "randomize: " << randomize << endl;
-
+        Debug << "minimum view cells: " << mMergeMinViewCells << endl;
+        Debug << "using area for pvs: " << mUseAreaForPvs << endl;
         Debug << "Split plane strategy: ";
         if (mSplitPlaneStrategy & RANDOM_POLYGON)
@@ -870 +873 @@
         
         //TODO: for kd split geometry already is box
-        if (1 && mUseAreaForPvs)
+        if (1)
         {
                 PolygonContainer::const_iterator it, it_end = tData.mGeometry->mPolys.end();
@@ -1012 +1015 @@
         {   // volume
                 pBack = pFront = pOverall * 0.5f;
+                
+#if 0
                 // box length substitute for probability
-#if 0
                 const float minBox = box.Min(axis);
                 const float maxBox = box.Max(axis);
@@ -1603 +1607 @@
 {
         ViewCell::NewMail();
-        CollectViewCells(mRoot, onlyValid, viewCells);
+        
+        CollectViewCells(mRoot, onlyValid, viewCells, true);
 }
 
@@ -1901 +1906 @@
 
 
+typedef pair<BspNode *, BspNodeGeometry *> bspNodePair;
+
 int VspBspTree::FindNeighbors(BspNode *n, vector<BspLeaf *> &neighbors,
                                                    const bool onlyUnmailed) const
 {
-        BspNodeGeometry geom;
-        ConstructGeometry(n, geom);
-
-        stack<BspNode *> nodeStack;
-        nodeStack.push(mRoot);
-
+        stack<bspNodePair> nodeStack;
+        
+        BspNodeGeometry nodeGeom;
+        ConstructGeometry(n, nodeGeom);
+        
         // split planes from the root to this node
         // needed to verify that we found neighbor leaf
@@ -1915 +1921 @@
         ExtractHalfSpaces(n, halfSpaces);
 
+
+        BspNodeGeometry *rgeom = new BspNodeGeometry();
+        ConstructGeometry(mRoot, *rgeom);
+
+        nodeStack.push(bspNodePair(mRoot, rgeom));
+
+
         while (!nodeStack.empty())
         {
-                BspNode *node = nodeStack.top();
+                BspNode *node = nodeStack.top().first;
+                BspNodeGeometry *geom = nodeStack.top().second;
+
                 nodeStack.pop();
 
-                if (node->IsLeaf())
-
-                {       // test if this leaf is in valid view space
-            if (node->TreeValid() &&
-                                node != n && 
-                                (!onlyUnmailed || !node->Mailed()))
+                bool isAdjacent = true;
+
+                // test all planes of current node if still adjacent
+                for (int i = 0; (i < halfSpaces.size()) && isAdjacent && (node != n); ++ i)
+                {
+                        const int cf =
+                                Polygon3::ClassifyPlane(geom->mPolys,
+                                                                                halfSpaces[i],
+                                                                                mEpsilon);
+
+                        if (cf == Polygon3::BACK_SIDE)
                         {
-                                // test all planes of current node if candidate really
-                                // is neighbour
-                                BspNodeGeometry neighborCandidate;
-                                ConstructGeometry(node, neighborCandidate);
-
-                                bool isAdjacent = true;
-                                for (int i = 0; (i < halfSpaces.size()) && isAdjacent; ++ i)
+                                isAdjacent = false;
+                        }
+                }
+
+                if (isAdjacent)
+                {
+                
+                        if (node->IsLeaf())
+                        {       
+                                // test if this leaf is in valid view space
+                                if (node->TreeValid() &&
+                                        node != n && 
+                                        (!onlyUnmailed || !node->Mailed()))
                                 {
-                                        const int cf =
-                                                Polygon3::ClassifyPlane(neighborCandidate.mPolys,
-                                                                                                halfSpaces[i],
-                                                                                                mEpsilon);
-
-                                        if (cf == Polygon3::BACK_SIDE)
-                                                isAdjacent = false;
+                                        // neighbor was found
+                                        neighbors.push_back(dynamic_cast<BspLeaf *>(node));
                                 }
-                                // neighbor was found
-                                if (isAdjacent)
-                                        neighbors.push_back(dynamic_cast<BspLeaf *>(node));
                         }
-                }
-                else
-                {
-                        BspInterior *interior = dynamic_cast<BspInterior *>(node);
-
-                        const int cf = Polygon3::ClassifyPlane(geom.mPolys,
-                                                                                                   interior->GetPlane(),
-                                                                                                   mEpsilon);
-
-                        if (cf == Polygon3::FRONT_SIDE)
-                                nodeStack.push(interior->GetFront());
                         else
-                                if (cf == Polygon3::BACK_SIDE)
-                                        nodeStack.push(interior->GetBack());
+                        {
+                                BspInterior *interior = dynamic_cast<BspInterior *>(node);
+
+                                const int cf = Polygon3::ClassifyPlane(nodeGeom.mPolys,
+                                                                                                           interior->GetPlane(),
+                                                                                                           mEpsilon);
+                        
+                                BspNode *front = interior->GetFront();
+                                BspNode *back = interior->GetBack();
+            
+                                BspNodeGeometry *fGeom = new BspNodeGeometry();
+                                BspNodeGeometry *bGeom = new BspNodeGeometry();
+
+                                geom->SplitGeometry(*fGeom,
+                                                                        *bGeom,
+                                                                        interior->GetPlane(),
+                                                                        mBox,
+                                                                        mEpsilon);
+                
+                                if (cf == Polygon3::FRONT_SIDE)
+                                {
+                                        nodeStack.push(bspNodePair(interior->GetFront(), fGeom));
+                                        DEL_PTR(bGeom);
+                                }
                                 else
                                 {
-                                        // random decision
-                                        nodeStack.push(interior->GetBack());
-                                        nodeStack.push(interior->GetFront());
+                                        if (cf == Polygon3::BACK_SIDE)
+                                        {
+                                                nodeStack.push(bspNodePair(interior->GetBack(), bGeom));
+                                                DEL_PTR(fGeom);
+                                        }
+                                        else
+                                        {       // random decision
+                                                nodeStack.push(bspNodePair(front, fGeom));
+                                                nodeStack.push(bspNodePair(back, bGeom));
+                                        }
                                 }
-                }
+                        }
+                }
+
+                DEL_PTR(geom);
         }
 
@@ -2642 +2681 @@
         if (0)
         {
+                cout << "finding additional merge candidates using geometry" << endl;
                 vector<BspLeaf *> leaves;
                 CollectLeaves(leaves, true);
@@ -2702 +2742 @@
         mergeStats.Start();
         // TODO: REMOVE LATER for performance!
-        const bool showMergeStats = true;
+        const bool showMergeStats = false;
         //BspMergeCandidate::sOverallCost = mBox.SurfaceArea() * mStat.maxPvs;
         long startTime = GetTime();
 
         if (mUseRaysForMerge)
+        {
+                cout << "collecting merge candidates (rays) ... ";
                 mergeStats.nodes = CollectMergeCandidates(rays);
+                cout << "fininshed collecting candidates" << endl;
+        }
         else
         {
@@ -2714 +2758 @@
                 mergeStats.nodes = CollectMergeCandidates(leaves);
         }
+        
 
         mergeStats.collectTime = TimeDiff(startTime, GetTime());
@@ -2722 +2767 @@
         int pass = 0;
         const int nextPass = 200;
+
+        cout << "starting merge ... ";
 
         //-- use priority queue to merge leaf pairs
@@ -2744 +2791 @@
 
                         MergeViewCells(mc.GetLeaf1(), mc.GetLeaf2());
-                        -- nViewCells;
-                        
+                                                
                         
                         // increase absolute merge cost
@@ -2774 +2820 @@
                                                 << "#CurrentPvs\n" << mc.GetLeaf1()->GetViewCell()->GetPvs().GetSize() << endl;
 
+                                        cout << "exporting view cells ... ";
                                         ViewCellContainer viewCells;    
                                         CollectViewCells(mRoot, false, viewCells);
                         
+                                        
                                         char s[64];
                                         sprintf(s, "merged_viewcells%07d.x3d", nViewCells);
@@ -2784 +2832 @@
                                         {
                                                 exporter->ExportGeometry(objects);
-                                                Debug << "vc size " << viewCells.size() << endl;
+                                                Debug << "vc size " << (int)viewCells.size() << " merge queue size: " << (int)mMergeQueue.size() << endl;
                                                 ViewCellContainer::const_iterator it, it_end = viewCells.end();
                 
@@ -2794 +2842 @@
                                                 delete exporter;
                                         }
+                                        cout << "finished " << endl;
                                 }
                         }
+
+                        -- nViewCells;
                         ++ mergeStats.merged;
-
                 }
                 // merge candidate not valid, because one of the leaves was already
@@ -2807 +2857 @@
                 }
         }
-
+        cout << "finished merge" << endl;
         mergeStats.mergeTime = TimeDiff(startTime, GetTime());
         mergeStats.Stop();
@@ -2911 +2961 @@
 
 
-float GetShuffledVcCost(BspLeaf *leaf, BspViewCell *vc1, BspViewCell *vc2, bool useArea)
+float VspBspTree::GetShuffledVcCost(BspLeaf *leaf, BspViewCell *vc1, BspViewCell *vc2) const
 {
         //const int pvs1 = SubtractedPvsSize(vc1, leaf, *leaf->mPvs);
@@ -2917 +2967 @@
         const int pvs2 = AddedPvsSize(vc2->GetPvs(), *leaf->mPvs);
 
+        if (pvs1 + pvs2 > mViewCellsManager->GetMaxPvsSize())
+                return 1e15f;
+
         float p1, p2;
 
-    if (useArea)
+    if (mUseAreaForPvs)
         {
                 p1 = vc1->GetArea() - leaf->mProbability;
@@ -3004 +3057 @@
         // the view cell should not be empty after the shuffle
         if (vc1->mLeaves.size() > 1)
-                shuffledCost1 = GetShuffledVcCost(leaf1, vc1, vc2, mUseAreaForPvs);
+                shuffledCost1 = GetShuffledVcCost(leaf1, vc1, vc2);
         if (vc2->mLeaves.size() > 1)
-                shuffledCost2 = GetShuffledVcCost(leaf2, vc2, vc1, mUseAreaForPvs);
+                shuffledCost2 = GetShuffledVcCost(leaf2, vc2, vc1);
 
         // shuffling unsuccessful