Changeset 683 for GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellBsp.cpp

Timestamp:

03/09/06 04:27:07 (18 years ago)

Author:

mattausch

Message:

fixed a bsp node geometry problem (debug code)

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellBsp.cpp (modified) (15 diffs)

GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellBsp.cpp

@@ -2317 +2317 @@
                         Plane3 halfSpace = dynamic_cast<BspInterior *>(interior)->GetPlane();
 
-            if (interior->GetFront() != lastNode)
+            if (interior->GetBack() != lastNode)
                                 halfSpace.ReverseOrientation();
 
@@ -2344 +2344 @@
 
 
-void BspTree::SetViewCellsManager(ViewCellsManager *vcm)
-{
-        mViewCellsManager = vcm;
-}
-
-
-void BspTree::ConstructGeometry(BspNode *n, BspNodeGeometry &geom) const
+void BspTree::ConstructGeometry(BspNode *n,
+                                                                BspNodeGeometry &geom) const
 {
         vector<Plane3> halfSpaces;
         ExtractHalfSpaces(n, halfSpaces);
 
-        PolygonContainer candidates;
+        PolygonContainer candidatePolys;
         vector<Plane3> candidatePlanes;
 
-        // bounded planes are added to the polygons (reverse polygons
-        // as they have to be outfacing
-        // comment: why is this?
+        // bounded planes are added to the polygons
         for (int i = 0; i < (int)halfSpaces.size(); ++ i)
         {
                 Polygon3 *p = GetBoundingBox().CrossSection(halfSpaces[i]);
-                
+
                 if (p->Valid(mEpsilon))
                 {
-                        candidates.push_back(p->CreateReversePolygon());
-
-                        Plane3 candidatePlane = p->GetSupportingPlane();//halfSpaces[i];
-                        //candidatePlane.ReverseOrientation();
-                        candidatePlanes.push_back(candidatePlane);
-
-                        DEL_PTR(p);
+                        candidatePolys.push_back(p);
+                        candidatePlanes.push_back(halfSpaces[i]);
                 }
         }
@@ -2381 +2369 @@
         {
                 VertexContainer vertices;
-        
+
                 for (int j = 0; j < 4; ++ j)
                         vertices.push_back(mBox.GetFace(i).mVertices[j]);
 
                 Polygon3 *poly = new Polygon3(vertices);
-                candidates.push_back(new Polygon3(vertices));
+
+                candidatePolys.push_back(poly);
                 candidatePlanes.push_back(poly->GetSupportingPlane());
         }
 
-
-        for (int i = 0; i < (int)candidates.size(); ++ i)
+        for (int i = 0; i < (int)candidatePolys.size(); ++ i)
         {
                 // polygon is split by all other planes
-                for (int j = 0; (j < (int)halfSpaces.size()) && candidates[i]; ++ j)
+                for (int j = 0; (j < (int)halfSpaces.size()) && candidatePolys[i]; ++ j)
                 {
                         if (i == j) // polygon and plane are coincident
@@ -2402 +2390 @@
                         Polygon3 *frontPoly, *backPoly;
 
-                        const int cf = candidates[i]->
-                                ClassifyPlane(halfSpaces[j], mEpsilon);
-                        
+                        const int cf =
+                                candidatePolys[i]->ClassifyPlane(halfSpaces[j],
+                                                                                                 mEpsilon);
+
                         switch (cf)
                         {
@@ -2411 +2400 @@
                                         backPoly = new Polygon3();
 
-                                        candidates[i]->Split(halfSpaces[j], 
-                                                                                 *frontPoly, 
-                                                                                 *backPoly,
-                                                                                 mEpsilon);
-
-                                        DEL_PTR(candidates[i]);
+                                        candidatePolys[i]->Split(halfSpaces[j],
+                                                                                         *frontPoly,
+                                                                                         *backPoly,
+                                                                                         mEpsilon);
+
+                                        DEL_PTR(candidatePolys[i]);
 
                                         if (frontPoly->Valid(mEpsilon))
-                                                candidates[i] = frontPoly;
+                                                candidatePolys[i] = frontPoly;
                                         else
                                                 DEL_PTR(frontPoly);
@@ -2425 +2414 @@
                                         DEL_PTR(backPoly);
                                         break;
-                                case Polygon3::BACK_SIDE:
-                                        DEL_PTR(candidates[i]);
+                                // polygon outside of halfspace
+                                case Polygon3::FRONT_SIDE:
+                                        DEL_PTR(candidatePolys[i]);
                                         break;
                                 // just take polygon as it is
-                                case Polygon3::FRONT_SIDE:
+                                case Polygon3::BACK_SIDE:
                                 case Polygon3::COINCIDENT:
                                 default:
@@ -2435 +2425 @@
                         }
                 }
-                
-                if (candidates[i])
-                {
-                        geom.Add(candidates[i], candidatePlanes[i]);
-                //      geom.mPolys.push_back(candidates[i]);
-                }
-        }
+
+                if (candidatePolys[i])
+                {
+                        geom.Add(candidatePolys[i], candidatePlanes[i]);
+                        //      geom.mPolys.push_back(candidates[i]);
+                }
+        }
+}
+
+
+void BspTree::SetViewCellsManager(ViewCellsManager *vcm)
+{
+        mViewCellsManager = vcm;
 }
 
@@ -2448 +2444 @@
 
 
-int BspTree::FindNeighbors(BspNode *n, vector<BspLeaf *> &neighbors,
+int BspTree::FindNeighbors(BspNode *n, vector<BspLeaf *> 
+                                                   &neighbors,
                                                    const bool onlyUnmailed) const
 {
@@ -2494 +2491 @@
                                                                                                         mEpsilon);
 
-                                                if (cf == Polygon3::BACK_SIDE)
+                                                if (cf == Polygon3::FRONT_SIDE)
                                                 {
                                                         isAdjacent = false;
@@ -2513 +2510 @@
                                                                                                         mEpsilon);
 
-                                                if (cf == Polygon3::BACK_SIDE)
+                                                if (cf == Polygon3::FRONT_SIDE)
                                                 {
                                                         isAdjacent = false;
@@ -2544 +2541 @@
                                                                 interior->GetPlane(),
                                                                 mBox,
+                                                                //0.0000001f);
                                                                 mEpsilon);
                 
-                        if (cf == Polygon3::FRONT_SIDE)
+                        if (cf == Polygon3::BACK_SIDE)
                         {
-                                nodeStack.push(bspNodePair(interior->GetFront(), fGeom));
-                                DEL_PTR(bGeom);
+                                nodeStack.push(bspNodePair(interior->GetBack(), bGeom));
+                                DEL_PTR(fGeom);
                         }
                         else
                         {
-                                if (cf == Polygon3::BACK_SIDE)
+                                if (cf == Polygon3::FRONT_SIDE)
                                 {
-                                        nodeStack.push(bspNodePair(interior->GetBack(), bGeom));
-                                        DEL_PTR(fGeom);
+                                        nodeStack.push(bspNodePair(interior->GetFront(), fGeom));
+                                        DEL_PTR(bGeom);
                                 }
                                 else
@@ -2570 +2568 @@
 
         return (int)neighbors.size();
-}
-
-
-BspLeaf *BspTree::GetRandomLeaf(const Plane3 &halfspace)
-{
-    stack<BspNode *> nodeStack;
-        nodeStack.push(mRoot);
-        
-        int mask = rand();
-  
-        while (!nodeStack.empty()) 
-        {
-                BspNode *node = nodeStack.top();
-                nodeStack.pop();
-          
-                if (node->IsLeaf()) 
-                {
-                        return dynamic_cast<BspLeaf *>(node);
-                } 
-                else 
-                {
-                        BspInterior *interior = dynamic_cast<BspInterior *>(node);
-                        BspNode *next;
-        
-                        BspNodeGeometry geom;
-                        // todo: not very efficient: constructs full cell everytime
-                        ConstructGeometry(interior, geom);
-
-                        const int cf = Polygon3::ClassifyPlane(geom.GetPolys(), 
-                                                                                                   halfspace, 
-                                                                                                   mEpsilon);
-
-                        if (cf == Polygon3::BACK_SIDE)
-                                next = interior->GetFront();
-                        else
-                                if (cf == Polygon3::FRONT_SIDE)
-                                        next = interior->GetFront();
-                        else 
-                        {
-                                // random decision
-                                if (mask & 1)
-                                        next = interior->GetBack();
-                                else
-                                        next = interior->GetFront();
-                                mask = mask >> 1;
-                        }
-
-                        nodeStack.push(next);
-                }
-        }
-        
-        return NULL;
 }
 
@@ -3085 +3031 @@
                                 splitsGeom = false;
 
-                                if (DotProd(mPlanes[i].mNormal,  splitPlane.mNormal > 0))
+                                if (DotProd(mPlanes[i].mNormal, splitPlane.mNormal > 0))
                                         back.Add(new Polygon3(mPolys[i]->mVertices), mPlanes[i]);
                                 else
@@ -3098 +3044 @@
         if (planePoly)
         {
-                // add polygon with reverse orientation to front cell
+        // add polygon with reverse orientation to front cell
                 Plane3 reversePlane(splitPlane);
                 reversePlane.ReverseOrientation();
 
-                //Debug << "poly normal : " << ndummy << " split plane normal " << splitPlane.mNormal << endl;
                 // add polygon with normal pointing into positive half space to back cell
                 back.Add(planePoly, splitPlane);
                 //back.mPolys.push_back(planePoly);
+
                 Polygon3 *reversePoly = planePoly->CreateReversePolygon();
                 front.Add(reversePoly, reversePlane);
                 Debug << "poly normal : " << reversePoly->GetSupportingPlane().mNormal << " split plane normal " << reversePlane.mNormal << endl;
         }
-
+        else Debug << "err" << endl;
 
         return splitsGeom;
@@ -3120 +3066 @@
 {
         if (!planePoly->Valid(epsilon))
+        {
+                Debug << "not valid!!" << endl;
                 DEL_PTR(planePoly);
-
+        }
         // polygon is split by all other planes
         for (int i = 0; (i < (int)mPolys.size()) && planePoly; ++ i)
         {
-#if 0
-                Plane3 plane = mPolys[i]->GetSupportingPlane();
-#else
+                //Plane3 plane = mPolys[i]->GetSupportingPlane();
                 Plane3 plane = mPlanes[i];
-        
-#endif
+
+                Debug << "*******************" << endl;
+                Debug << "support: " << mPolys[i]->GetSupportingPlane() << endl;
+                Debug << "plane: " << mPlanes[i] << endl;
+
                 /// don't use epsilon here to get exact split planes
                 const int cf =