Changeset 313 for trunk/VUT/GtpVisibilityPreprocessor/src/X3dExporter.cpp

Timestamp:

10/10/05 04:19:59 (19 years ago)

Author:

mattausch

Message:

bsp viewcells now work

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/X3dExporter.cpp (modified) (11 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/X3dExporter.cpp

@@ -120 +120 @@
 }
 
-void X3dExporter::ExportViewCells(ViewCellContainer *viewCells)
-{
-        ViewCellContainer::iterator it, it_end = viewCells->end();
-
-        for (it = viewCells->begin(); it != it_end; ++it)
+void 
+X3dExporter::ExportViewCells(const ViewCellContainer &viewCells)
+{
+        ViewCellContainer::const_iterator it, it_end = viewCells.end();
+
+        for (it = viewCells.begin(); it != it_end; ++ it)
                 ExportViewCell(*it);
 }
+
 void
 X3dExporter::ExportViewCell(ViewCell *viewCell)
@@ -274 +276 @@
 }
 
-void X3dExporter::ExportPolygons(PolygonContainer *polys)
+void X3dExporter::ExportPolygons(const PolygonContainer &polys)
 {
         stream << "<Shape>" << endl;
@@ -314 +316 @@
     VertexContainer::const_iterator vi;  
         
-        for (pit = polys->begin(); pit != polys->end(); ++pit)
+        for (pit = polys.begin(); pit != polys.end(); ++pit)
         {
                 Polygon3 *poly = *pit;
@@ -327 +329 @@
         
         stream << "<Coordinate  point=\"" << endl;
-        for (pit = polys->begin(); pit != polys->end(); ++pit)
+        for (pit = polys.begin(); pit != polys.end(); ++pit)
         {
                 Polygon3 *poly = *pit;
@@ -453 +455 @@
                 ViewCellContainer::iterator new_end = unique(foundViewCells.begin(), foundViewCells.end());
                 foundViewCells.erase(new_end, foundViewCells.end());
-                ExportViewCells(&foundViewCells);
+                ExportViewCells(foundViewCells);
 
                 Debug << "Number of view cells after erasing dublicates: " << (int)foundViewCells.size() << endl;
@@ -533 +535 @@
                         if (vc->mPassingRays.mRays) 
                         {
-                                float importance = vc->mPassingRays.mContributions/(float)vc->mPassingRays.mRays;
+                                float importance = 
+                                        vc->mPassingRays.mContributions / (float)vc->mPassingRays.mRays;
 
                                 mForcedMaterial.mDiffuseColor.r = importance;
@@ -616 +619 @@
         BspNode *mNode;
 
-        PolygonContainer *mPolygons;
         vector<Plane3 *> mPlanes;
         vector<bool> mSides;
         bool mIsFront;
 
-        BspSplitData(BspNode *node, PolygonContainer *polys): 
-        mNode(node), mPolygons(polys), mIsFront(false)
+        BspSplitData(BspNode *node): 
+        mNode(node), mIsFront(false)
         {};     
         BspSplitData(BspNode *node, 
-                                 PolygonContainer *polys, 
                                  vector<Plane3 *> planes, 
                                  vector<bool> sides, 
                                  bool isFront): 
-        mNode(node), mPolygons(polys), mPlanes(planes), 
+        mNode(node), mPlanes(planes), 
         mSides(sides), mIsFront(isFront)
         {};
@@ -636 +637 @@
 void X3dExporter::ExportBspSplits(const BspTree &tree)
 {
-        int mask = Random(50000);
-        
         std::stack<BspSplitData> tStack;
 
-        BspSplitData tData(tree.GetRoot(), new PolygonContainer());
+        BspSplitData tData(tree.GetRoot());
         tStack.push(tData);
   
+        PolygonContainer polys;
+
         while (!tStack.empty())
         {
@@ -652 +653 @@
                 {
                         BspInterior *interior = dynamic_cast<BspInterior *>(tData.mNode);
-
-                        tData.mPlanes.push_back(interior->GetPlane());
-                        tData.mSides.push_back(tData.mIsFront);
+                        if (tData.mNode != tree.GetRoot())
+                                tData.mSides.push_back(tData.mIsFront); // add current side
 
                         // bounded plane is added to the polygons
-                        Polygon3 *planePoly = tree.GetBoundingBox().BoundPlane(*tData.mPlanes.back());
+                        Polygon3 *planePoly = tree.GetBoundingBox().BoundPlane(*interior->GetPlane());
                 
-                        PolygonContainer *frontPolys = new PolygonContainer();
-                        PolygonContainer *backPolys = new PolygonContainer();
-                        PolygonContainer coincident;
-
-                        int splits = 0;
-                
-                        // split polygons with respect to split plane
-                        interior->SplitPolygons(tData.mPolygons, 
-                                                                        frontPolys, 
-                                                                        backPolys,
-                                                                        &coincident,
-                                                                        splits, 
-                                                                        false);
-
                         // do all the splits with the previous planes
                         for (int i = 0; i < (int)tData.mPlanes.size(); ++i)
@@ -692 +678 @@
                                         else
                                         {
-                                                Debug << "take backpoly" << endl;
                                                 planePoly = backPoly;
                                                 DEL_PTR(frontPoly);
@@ -699 +684 @@
                         }
 
-                        PolygonContainer *polys;
-                        BspNode *next;
-                        bool side = false;
-
-                        // random decision
-                        if (mask & 1)
-                        {
-                                next = interior->GetBack();
-                                polys = backPolys;
-                                CLEAR_CONTAINER(*frontPolys);
-                                DEL_PTR(frontPolys);
-                                side = false;
-                        }
+                        tData.mPlanes.push_back(interior->GetPlane()); // add plane to split planes
+                        if (planePoly->Valid())
+                                polys.push_back(planePoly);
                         else
                         {
-                                next = interior->GetFront();
-                                polys = frontPolys;
-                                
-                                CLEAR_CONTAINER(*backPolys);
-                                DEL_PTR(backPolys);
-                                side = true;
+                                Debug << "polygon not valid: " << *planePoly << " size: " << planePoly->mVertices.size() << endl;
+                                DEL_PTR(planePoly);
                         }
-
-                        mask = mask >> 1;
-                        polys->push_back(planePoly);
-
                         // push the children on the stack
-                        tStack.push(BspSplitData(next, polys, tData.mPlanes, 
-                                                                         tData.mSides, side));
-                        //tStack.push(BspSplitData(interior->GetBack(), backPolys, 
-                        //                                               tData.mPlanes, tData.mSides, false));
-
-                        // clean up
-                        CLEAR_CONTAINER(coincident); // NOTE: should contain nothing
-                        CLEAR_CONTAINER(*tData.mPolygons);
-                        DEL_PTR(tData.mPolygons);
+                        tStack.push(BspSplitData(interior->GetFront(), tData.mPlanes, tData.mSides, true));
+                        tStack.push(BspSplitData(interior->GetBack(), tData.mPlanes, tData.mSides, false));
                 }
-                else // reached leaf
+        }       
+        ExportPolygons(polys);
+        CLEAR_CONTAINER(polys);
+}
+
+void X3dExporter::ExportBspSplitPlanes(const BspTree &tree)
+{
+        std::stack<BspNode *> tStack;
+
+        tStack.push(tree.GetRoot());
+  
+        PolygonContainer polys;
+
+        while (!tStack.empty())
+        {
+                // filter polygons donw the tree
+                BspNode *node = tStack.top();
+            tStack.pop();       
+                
+                if (!node->IsLeaf())
                 {
-                        //Debug << "\nsplits: " << endl;
-                        //for (int i = 0; i < (int)tData.mSides.size(); ++ i)Debug << " " << tData.mSides[i];
-                        ExportPolygons(tData.mPolygons);
-                        
-                        // clean up
-                        CLEAR_CONTAINER(*tData.mPolygons);
-                        DEL_PTR(tData.mPolygons);
+                        BspInterior *interior = dynamic_cast<BspInterior *>(node);
+
+                        // bounded plane is added to the polygons
+                        polys.push_back(tree.GetBoundingBox().BoundPlane(*interior->GetPlane()));
+                
+                        // push the children on the stack
+                        tStack.push(interior->GetBack());
+                        tStack.push(interior->GetFront());
                 }
         }
-}
+
+        ExportPolygons(polys);
+        CLEAR_CONTAINER(polys);
+}