Changeset 383 for trunk/VUT/GtpVisibilityPreprocessor/src

Timestamp:

11/06/05 01:24:55 (19 years ago)

Author:

mattausch

Message:

 

Location:

trunk/VUT/GtpVisibilityPreprocessor/src

Files:

• Exporter.h (modified) (1 diff)
• SamplingPreprocessor.cpp (modified) (4 diffs)
• ViewCellBsp.cpp (modified) (14 diffs)
• ViewCellBsp.h (modified) (5 diffs)
• VssPreprocessor.cpp (modified) (1 diff)
• X3dExporter.cpp (modified) (5 diffs)
• X3dExporter.h (modified) (1 diff)

trunk/VUT/GtpVisibilityPreprocessor/src/Exporter.h

@@ -71 +71 @@
   ExportBspSplitPlanes(const BspTree &tree) = 0;
   virtual void 
-  ExportBspSplits(const BspTree &tree) = 0;
+  ExportBspSplits(const BspTree &tree, const bool exportDepth = false) = 0;
   virtual void
   ExportLeavesGeometry(const BspTree &tree, const vector<BspLeaf *> &leaves) = 0;

trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.cpp

@@ -600 +600 @@
                 }
 
-                //-- visualization of the bsp splits
+                //-- visualization of the BSP splits
                 bool exportSplits = false;
                 environment->GetBoolValue("BspTree.exportSplits", exportSplits);
@@ -703 +703 @@
                                                         
                         mSampleRays.push_back(new Ray(ray));
-                        Debug << "abba " << mSampleRays.size() << endl;
                 }
                 else
@@ -727 +726 @@
         else if ((int)mSampleRays.size() < mPostProcessSamples)
         {
-                Debug << "police " << mSampleRays.size() << endl;
                 mSampleRays.push_back(new Ray(ray));
         }
@@ -779 +777 @@
                 exporter->SetForcedMaterial(m);
                 exporter->SetWireframe();
-                exporter->ExportBspSplits(*mBspTree);
+                exporter->ExportBspSplits(*mBspTree, true);
 
                 // take forced material, else big scenes cannot be viewed

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -1084 +1084 @@
         if (sSplitPlaneStrategy & RANDOM_POLYGON)
         {
-                Vector3 pt[3];
-                for (int j = 0; j < 3; j ++)
-                {
-                        int idx = Random((int)rays.size());
-                        pt[j] = rays[idx]->mRay->Extrap(rays[idx]->mMaxT);
-                }
-
-                return Plane3(pt[0], pt[1], pt[2]);
-
-        //return polys[Random((int)polys.size())]->GetSupportingPlane();
+                return polys[Random((int)polys.size())]->GetSupportingPlane();
         }
 
         // use heuristics to find appropriate plane
-        return SelectPlaneHeuristics(polys, rays, sMaxPolyCandidates, sMaxRayCandidates);
-}
-
-Plane3 BspTree::SelectPlaneHeuristics(PolygonContainer &polys,
+        return SelectPlaneHeuristics(leaf, 
+                                         polys, 
+                                                                 rays, 
+                                                                 sMaxPolyCandidates, 
+                                                                 sMaxRayCandidates);
+}
+
+Plane3 BspTree::SelectPlaneHeuristics(BspLeaf *leaf,
+                                                                          PolygonContainer &polys,
                                                                           const BoundedRayContainer &rays,
                                                                           const int maxPolyCandidates,
@@ -1108 +1104 @@
         int bestPlaneIdx = 0;
         
-        int limit = maxPolyCandidates > 0 ? Min((int)polys.size(), maxPolyCandidates) : (int)polys.size();
+        int limit = maxPolyCandidates > 0 ? 
+                Min((int)polys.size(), maxPolyCandidates) : (int)polys.size();
         
         int candidateIdx = limit;
 
-        //Debug << endl;
-        /*for (int i = 0; i < limit; ++ i)
+        for (int i = 0; i < limit; ++ i)
         {
                 candidateIdx = GetNextCandidateIdx(candidateIdx, polys);
-
-                Plane3 candidatePlane = polys[candidateIdx]->GetSupportingPlane();
+                
+                // evaluate current candidate
+                const float candidateCost = 
+                        SplitPlaneCost(leaf,
+                                       polys[candidateIdx]->GetSupportingPlane(), 
+                                                   polys, rays);
+
                 //Debug << polys[candidateIdx] << endl;
-                // evaluate current candidate
-                float candidateCost = SplitPlaneCost(candidatePlane, polys, rays);
-                        
                 if (candidateCost < lowestCost)
                 {
@@ -1127 +1125 @@
                         lowestCost = candidateCost;
                 }
-        }*/
+        }
         
         //limit = maxRaysCandidates > 0 ? Min((int)rays.size(), maxRayCandidates) : (int)rays.size();
@@ -1140 +1138 @@
                 for (int j = 0; j < 3; j ++)
                 {
-                        idx[j] = Random((int)rays.size());
-                        pt[j] = rays[idx[j]]->mRay->Extrap(rays[idx[j]]->mMaxT);
-                }
-
-                float candidateCost = SplitPlaneCost(Plane3(pt[0], pt[1], pt[2]), polys, rays);
+                        idx[j] = Random((int)rays.size() * 2);
+                                
+                        if (idx[j] < (int)rays.size())
+                                pt[j] = rays[idx[j]]->mRay->Extrap(rays[idx[j]]->mMinT);
+                        else
+                        {
+                                idx[j] -= (int)rays.size();
+                                pt[j] = rays[idx[j]]->mRay->Extrap(rays[idx[j]]->mMaxT);
+                        }
+                                        
+                }
+
+                const float candidateCost =
+                        SplitPlaneCost(leaf, Plane3(pt[0], pt[1], pt[2]), 
+                                                   polys, rays);
 
                 if (candidateCost < lowestCost)
@@ -1157 +1165 @@
         if (chooseFromRays)
         {
+                Debug << "choose ray plane: " << lowestCost << endl;
                 return Plane3(rays[bestIdx[0]]->mRay->Extrap(rays[bestIdx[0]]->mMaxT),
                                           rays[bestIdx[1]]->mRay->Extrap(rays[bestIdx[1]]->mMaxT),
@@ -1177 +1186 @@
 }
 
-float BspTree::SplitPlaneCost(const Plane3 &candidatePlane, 
+float BspTree::SplitPlaneCost(BspLeaf *leaf, 
+                                                          const Plane3 &candidatePlane, 
                                                           const PolygonContainer &polys) const
 {
@@ -1316 +1326 @@
 }
 
-float BspTree::SplitPlaneCost(const Plane3 &candidatePlane, 
+float BspTree::SplitPlaneCost(BspLeaf *leaf,
+                                                          const Plane3 &candidatePlane, 
                                                           const BoundedRayContainer &rays) const
 {
@@ -1333 +1344 @@
         Intersectable::NewMail(); const int frontAndBackId = ViewCell::sMailId;
 
-        /*PolygonContainer cell;
+        PolygonContainer cell;
         PolygonContainer front;
         PolygonContainer back;
 
-        ConstructGeometry(currentNode, cell);
-        ConstructChildrenGeometry(front, cell, planes, sides);
-        ConstructChildrenGeometry(back, cell, planes, sides);*/
-
-
+        vector<Plane3 *> planes;
+        vector<bool> sides;
+
+        ExtractSplitPlanes(leaf, planes, sides);
+
+        ConstructGeometry(leaf, cell);
+        ConstructChildGeometry(front, cell, planes, sides, candidatePlane, true);
+        ConstructChildGeometry(back, cell, planes, sides, candidatePlane, false);
+
+        CLEAR_CONTAINER(cell);
+        CLEAR_CONTAINER(front);
+        CLEAR_CONTAINER(back);
+        
         int frontRays = 0;
         int backRays = 0;
@@ -1475 +1494 @@
 }
 
-float BspTree::SplitPlaneCost(const Plane3 &candidatePlane, 
+float BspTree::SplitPlaneCost(BspLeaf *leaf,
+                                                          const Plane3 &candidatePlane, 
                                                           const PolygonContainer &polys,                                                          
                                                           const BoundedRayContainer &rays) const
@@ -1497 +1517 @@
                 (sSplitPlaneStrategy & BLOCKED_RAYS))
         {
-        val += SplitPlaneCost(candidatePlane, polys);
+        val += SplitPlaneCost(leaf, candidatePlane, polys);
         }
 
@@ -1505 +1525 @@
                 (sSplitPlaneStrategy & PVS))
         {
-                val += SplitPlaneCost(candidatePlane, rays);
+                val += SplitPlaneCost(leaf, candidatePlane, rays);
         }
 
@@ -2019 +2039 @@
 }
 
-bool BspTree::ComputeChildrenGeometry(PolygonContainer &newCell,
-                                                                          const PolygonContainer &cell,
-                                                                          const vector<Plane3> &planes,
-                                                                          const vector<bool> &sides,
-                                                                          const Plane3 &splitPlane,
-                                                                          const bool side) const
+bool BspTree::ConstructChildGeometry(PolygonContainer &newCell,
+                                                                         const PolygonContainer &cell,
+                                                                         const vector<Plane3 *> &planes,
+                                                                         const vector<bool> &sides,
+                                                                         const Plane3 &splitPlane,
+                                                                         const bool side) const
 {
         // get cross section of new polygon
@@ -2034 +2054 @@
         for (int i = 0; (i < planes.size()) && inside; ++ i)
         {
-                const int cf = planePoly->ClassifyPlane(planes[i]);
+                const int cf = planePoly->ClassifyPlane(*planes[i]);
                         
                 // split new polygon with all previous planes
@@ -2046 +2066 @@
                                         Polygon3 *backPoly = new Polygon3();
 
-                                        planePoly->Split(planes[i], *frontPoly, *backPoly, splitPts);
+                                        planePoly->Split(*planes[i], *frontPoly, *backPoly, splitPts);
                                         DEL_PTR(planePoly);
 

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.h

@@ -459 +459 @@
                 @returns true if plane contributes to the cell.
         */
-        bool ComputeChildrenGeometry(PolygonContainer &newCell,
-                                                        const PolygonContainer &cell,
-                                                        const vector<Plane3> &planes,
-                                                        const vector<bool> &sides,
-                                                        const Plane3 &splitPlane,
-                                                        const bool side) const;
+        bool ConstructChildGeometry(PolygonContainer &newCell,
+                                                            const PolygonContainer &cell,
+                                                            const vector<Plane3 *> &planes,
+                                                            const vector<bool> &sides,
+                                                            const Plane3 &splitPlane,
+                                                            const bool side) const;
 
 
@@ -540 +540 @@
                 @returns the cost of the candidate split plane
         */
-        float SplitPlaneCost(const Plane3 &candidatePlane,
+        float SplitPlaneCost(BspLeaf *leaf, 
+                                 const Plane3 &candidatePlane,
                                                  const PolygonContainer &polys,                                                  
                                                  const BoundedRayContainer &rays) const;
@@ -548 +549 @@
                 @returns the cost of the candidate split plane
         */
-        float SplitPlaneCost(const Plane3 &candidatePlane,
+        float SplitPlaneCost(BspLeaf *leaf, 
+                                 const Plane3 &candidatePlane,
                                                  const PolygonContainer &polys) const;
 
@@ -555 +557 @@
                 @returns the cost of the candidate split plane
         */
-        float SplitPlaneCost(const Plane3 &candidatePlane,
+        float SplitPlaneCost(BspLeaf *leaf,
+                                 const Plane3 &candidatePlane,
                                                  const BoundedRayContainer &polys) const;
 
@@ -608 +611 @@
                 @param maxRayCandidates the maximal number of ray candidates
         */
-        Plane3 SelectPlaneHeuristics(PolygonContainer &polys, 
+        Plane3 SelectPlaneHeuristics(BspLeaf *leaf,
+                                         PolygonContainer &polys, 
                                                                  const BoundedRayContainer &rays,
                                                                  const int maxPolyCandidates,

trunk/VUT/GtpVisibilityPreprocessor/src/VssPreprocessor.cpp

@@ -131 +131 @@
   long startTime = GetTime();
   
-  int i;
   int totalSamples = 0;
 

trunk/VUT/GtpVisibilityPreprocessor/src/X3dExporter.cpp

@@ -696 +696 @@
         vector<bool> mSides;
         bool mIsFront;
+        int mDepth;
 
         BspSplitData(BspNode *node): 
-        mNode(node), mIsFront(false)
+        mNode(node), mIsFront(false), mDepth(0)
         {};     
+
         BspSplitData(BspNode *node, 
                                 vector<Plane3 *> planes, 
                                 vector<bool> sides, 
-                                bool isFront): 
-        mNode(node), mPlanes(planes), 
-        mSides(sides), mIsFront(isFront)
+                                const bool isFront,
+                                const int depth): 
+        mNode(node), mPlanes(planes), mSides(sides), 
+        mIsFront(isFront), mDepth(depth)
         {};
 };
 
-void X3dExporter::ExportLeavesGeometry(const BspTree &tree, const vector<BspLeaf *> &leaves)
+void X3dExporter::ExportLeavesGeometry(const BspTree &tree, 
+                                                                           const vector<BspLeaf *> &leaves)
 {
         vector<BspLeaf *>::const_iterator it, it_end = leaves.end();
@@ -724 +728 @@
 }
 
-void X3dExporter::ExportBspSplits(const BspTree &tree)
+void X3dExporter::ExportBspSplits(const BspTree &tree,
+                                                                  const bool exportDepth)
 {
         std::stack<BspSplitData> tStack;
@@ -732 +737 @@
   
         PolygonContainer polys;
+        vector <int> depths;
+
+        int maxDepth = 0;
 
         while (!tStack.empty())
@@ -739 +747 @@
             tStack.pop();       
                 
-                if (!tData.mNode->IsLeaf())
+                if (tData.mNode->IsLeaf())
+                {
+                        if (tData.mDepth > maxDepth)
+                                maxDepth = tData.mDepth;
+                }
+                else
                 {
                         BspInterior *interior = dynamic_cast<BspInterior *>(tData.mNode);
 
+                        // add current side of split plane
                         if (tData.mNode != tree.GetRoot())
-                                tData.mSides.push_back(tData.mIsFront); // add current side of split plane
+                                tData.mSides.push_back(tData.mIsFront);
 
                         // bounded plane is added to the polygons
-                        Polygon3 *planePoly = tree.GetBoundingBox().CrossSection(*interior->GetPlane());
+                        Polygon3 *planePoly = 
+                                tree.GetBoundingBox().CrossSection(*interior->GetPlane());
                 
                         // do all the splits with the previous planes
@@ -778 +793 @@
 
                         if (planePoly->Valid())
+                        {
                                 polys.push_back(planePoly);
+                                depths.push_back(tData.mDepth);
+                        }
                         else
                                 DEL_PTR(planePoly);
                         
                         // push the children on the stack
-                        tStack.push(BspSplitData(interior->GetFront(), tData.mPlanes, tData.mSides, true));
-                        tStack.push(BspSplitData(interior->GetBack(), tData.mPlanes, tData.mSides, false));
-                }
-        }       
-        ExportPolygons(polys);
+                        tStack.push(BspSplitData(interior->GetFront(), tData.mPlanes, 
+                                                     tData.mSides, true, tData.mDepth + 1));
+                        tStack.push(BspSplitData(interior->GetBack(), tData.mPlanes, 
+                                                     tData.mSides, false, tData.mDepth + 1));
+                }
+        }
+
+        if (maxDepth > 0)
+        {       
+                mUseForcedMaterial = true;
+                        
+                for (int i = 0; i < (int)polys.size(); ++ i)
+                {
+                        mForcedMaterial.mDiffuseColor.b = 1.0f;
+                        float importance =  (float)depths[i]/ (float)maxDepth;
+            
+                        mForcedMaterial.mDiffuseColor.r = importance;
+                        mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
+
+                        ExportPolygon(polys[i]);
+                }
+        }
+        else
+        {
+                ExportPolygons(polys);
+        }
+
         CLEAR_CONTAINER(polys);
 }

trunk/VUT/GtpVisibilityPreprocessor/src/X3dExporter.h

@@ -75 +75 @@
   
   virtual void 
-  ExportBspSplits(const BspTree &tree);
+  ExportBspSplits(const BspTree &tree, const bool exportDepth);
 
   virtual void