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

Timestamp:

01/19/06 23:36:01 (18 years ago)

Author:

mattausch

Message:

started implementing merge visualization !not working!!

File:

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

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp

@@ -38 +38 @@
 bool BspMergeCandidate::sUseArea = false;
 
+
 /********************************************************************/
 /*                  class VspBspTree implementation                 */
 /********************************************************************/
+
 
 VspBspTree::VspBspTree():
@@ -498 +500 @@
 
                 mStat.contributingSamples += conSamp;
-                mStat.sampleContributions += sampCon;
+                mStat.sampleContributions +=(int) sampCon;
 
                 //-- store additional info
@@ -1915 +1917 @@
 typedef pair<BspNode *, BspNodeGeometry *> bspNodePair;
 
+
 int VspBspTree::FindNeighbors(BspNode *n, vector<BspLeaf *> &neighbors,
                                                    const bool onlyUnmailed) const
@@ -1925 +1928 @@
         // split planes from the root to this node
         // needed to verify that we found neighbor leaf
+        // TODO: really needed?
         vector<Plane3> halfSpaces;
         ExtractHalfSpaces(n, halfSpaces);
@@ -1934 +1938 @@
         nodeStack.push(bspNodePair(mRoot, rgeom));
 
+        Debug << "here77" << endl;
 
         while (!nodeStack.empty())
@@ -1942 +1947 @@
                 nodeStack.pop();
 
-                bool isAdjacent = true;
-
-                
+                if (node->IsLeaf())
+                {       
+                        Debug << "here22" << endl;
+                        // test if this leaf is in valid view space
+                        if (node->TreeValid() &&
+                                (node != n) && 
+                                (!onlyUnmailed || !node->Mailed()))
+                        {
+                                Debug << "here" << endl;
+                                bool isAdjacent = true;
 #if 1
-                // 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)
-                        {
-                                isAdjacent = false;
-                        }
-                }
-#else
-                // test all planes of current node if still adjacent
-                for (int i = 0; i < nodeGeom.size()) && isAdjacent && (node != n); ++ i)
-                {
-                        Polygon3 *poly = nodeGeom->mPolys[i];
-
-                        const int cf =
-                                Polygon3::ClassifyPlane(geom->mPolys,
-                                                                                poly->GetSupportingPlane(),
-                                                                                mEpsilon);
-
-                        if (cf == Polygon3::BACK_SIDE)
-                        {
-                                isAdjacent = false;
-                        }
-                }
+
+                                // test all planes of current node if still adjacent
+                                for (int i = 0; (i < halfSpaces.size()) && isAdjacent; ++ i)
+                                {
+                                        const int cf =
+                                                Polygon3::ClassifyPlane(geom->mPolys,
+                                                                                                halfSpaces[i],
+                                                                                                mEpsilon);
+
+                                        if (cf == Polygon3::BACK_SIDE)
+                                        {
+                                                isAdjacent = false;
+                                        }
+                                }
+#else // TODO: why is this wrong??
+                                // test all planes of current node if still adjacent
+                                for (int i = 0; (i < (int)nodeGeom.mPolys.size()) && isAdjacent; ++ i)
+                                {
+                                        Debug << "here33" << endl;
+                                        Polygon3 *poly = nodeGeom.mPolys[i];
+
+                                        const int cf =
+                                                Polygon3::ClassifyPlane(geom->mPolys,
+                                                                                                poly->GetSupportingPlane(),
+                                                                                                mEpsilon);
+
+                                        if (cf == Polygon3::BACK_SIDE)
+                                        {
+                                                isAdjacent = false;
+                                        }
+                                }
 #endif
-                if (isAdjacent)
-                {
-                
-                        if (node->IsLeaf())
-                        {       
-                                // test if this leaf is in valid view space
-                                if (node->TreeValid() &&
-                                        node != n && 
-                                        (!onlyUnmailed || !node->Mailed()))
-                                {
-                                        // neighbor was found
+                                Debug << "here2" << endl;
+                                // neighbor was found
+                                if (isAdjacent)
                                         neighbors.push_back(dynamic_cast<BspLeaf *>(node));
-                                }
                         }
                         else
@@ -2505 +2510 @@
 
 
-bool VspBspTree::MergeViewCells(BspLeaf *l1, BspLeaf *l2) const
+bool VspBspTree::MergeViewCells(BspLeaf *l1, BspLeaf *l2) //const
 {
         //-- change pointer to view cells of all leaves associated
@@ -2545 +2550 @@
 
         // clean up old view cells
-        DEL_PTR(fVc);
-        DEL_PTR(bVc);
+        if (0)
+        {
+                DEL_PTR(fVc);
+                DEL_PTR(bVc);
+        }
+        else // throw them into old view cells container
+        {
+                fVc->mMailbox = -1;
+                bVc->mMailbox = -1;
+
+                mOldViewCells.push_back(fVc);
+                mOldViewCells.push_back(bVc);
+
+                mNewViewCells.push_back(vc);
+        }
 
         return true;
@@ -2764 +2782 @@
         BspMergeCandidate::sUseArea = mUseAreaForPvs;
 
+        // the current view cells are kept in this container
+        ViewCellContainer viewCells;
+        ViewCell::NewMail();
+        CollectViewCells(mRoot, true, viewCells, true);
+        ViewCell::NewMail();
+
         MergeStatistics mergeStats;
         mergeStats.Start();
         // TODO: REMOVE LATER for performance!
-        const bool showMergeStats = false;
+        const bool showMergeStats = true;
         //BspMergeCandidate::sOverallCost = mBox.SurfaceArea() * mStat.maxPvs;
         long startTime = GetTime();
@@ -2846 +2870 @@
 
                                         cout << "exporting view cells ... ";
-                                        ViewCellContainer viewCells;    
-                                        CollectViewCells(mRoot, false, viewCells);
-                        
-                                        
+                                                                
+                                
+                                        ViewCellContainer::const_iterator vit, vit_end = viewCells.end();
+
+                                        Debug << "here2111 " << viewCells.size() << endl;
+                                        for (int i = 0; i < viewCells.size(); ++ i)
+                                        {
+                                                while (!viewCells.empty() && (viewCells.back()->mMailbox == -1))
+                                                {
+                                                        Debug << "here244" << endl;
+                                                        viewCells.pop_back();
+                                                }
+
+                                                // already merged view cell, put it to end of vector
+                                                if ((i < viewCells.size()) && (viewCells[i]->mMailbox == -1))
+                                                {
+                                                        Debug << "here2" << endl;
+                                                        swap(viewCells[i], viewCells.back());
+                                                }
+                                        }
+                                
+                                        cout << "finished" << endl;
+                                        // not part of any leaf
+                                        CLEAR_CONTAINER(mOldViewCells);
+
+                                        int newVcSize = (int)mNewViewCells.size();
+                                        // add new view cells to container
+                                        while (!mNewViewCells.empty())
+                                        {
+                                                viewCells.push_back(mNewViewCells.back());
+                                                mNewViewCells.pop_back();
+                                        }
+
                                         char s[64];
                                         sprintf(s, "merged_viewcells%07d.x3d", nViewCells);
@@ -2860 +2913 @@
                                                 ViewCellContainer::const_iterator it, it_end = viewCells.end();
                 
+                                                int i = (int)viewCells.size();
                                                 for (it = viewCells.begin(); it != it_end; ++ it)
                                                 {
+                                                        Material m = RandomMaterial();
+                                                        if (i-- == newVcSize)
+                                                        {
+                                                                m.mDiffuseColor.r = 1;
+                                                                m.mDiffuseColor.g = 0;
+                                                                m.mDiffuseColor.b = 0;
+                                                        }
+                                                        exporter->SetForcedMaterial(m);
                                                         mViewCellsManager->ExportVcGeometry(exporter, *it);
                                                 }
@@ -2882 +2944 @@
                 }
         }
+
+
         cout << "finished merge" << endl;
         mergeStats.mergeTime = TimeDiff(startTime, GetTime());