Changeset 573

Timestamp:

01/24/06 10:06:58 (18 years ago)

Author:

mattausch

Message:

implemented functtion for view cell construction

Location:

trunk/VUT/GtpVisibilityPreprocessor

Files:

• scripts/default.env (modified) (1 diff)
• src/Preprocessor.h (modified) (1 diff)
• src/Pvs.h (modified) (1 diff)
• src/ViewCellBsp.cpp (modified) (2 diffs)
• src/ViewCellsManager.cpp (modified) (1 diff)
• src/ViewCellsManager.h (modified) (1 diff)
• src/VspBspTree.cpp (modified) (10 diffs)
• src/VspBspTree.h (modified) (1 diff)

trunk/VUT/GtpVisibilityPreprocessor/scripts/default.env

@@ -30 +30 @@
 VssPreprocessor {
         samplesPerPass  100000
-        initialSamples 2000000
+        initialSamples 6000000
         vssSamples 0
         vssSamplesPerPass 500000

trunk/VUT/GtpVisibilityPreprocessor/src/Preprocessor.h

@@ -118 +118 @@
                            );
   
+  virtual void CastRays(SimpleRayContainer &rays,
+          VssRayContainer &vssRays) {};
+
   /// scene graph loaded from file
   SceneGraph *mSceneGraph;

trunk/VUT/GtpVisibilityPreprocessor/src/Pvs.h

@@ -133 +133 @@
         std::map<T, PvsData<T>, LtSample<T> >::const_iterator it;
 
+        mEntries = a.mEntries;
         // todo: copy all elements instead of inserting
-        for (it = a.mEntries.begin(); it != a.mEntries.end(); ++ it)
-                mEntries.insert(*it);
+        //for (it = a.mEntries.begin(); it != a.mEntries.end(); ++ it)
+        //      mEntries.insert(*it);
         
         for (it = b.mEntries.begin(); it != b.mEntries.end(); ++ it)

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -201 +201 @@
 }
 
+
 bool BspLeaf::IsLeaf() const 
 { 
@@ -206 +207 @@
 }
 
-/****************************************************************/
-/*                  class BspTree implementation                */
-/****************************************************************/
+
+/******************************************************************/
+/*                    class BspTree implementation                */
+/******************************************************************/
 
 BspTree::BspTree():  

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.cpp

@@ -88 +88 @@
 
 
+int ViewCellsManager::CastPassSamples(int samplesPerPass, 
+                                                                          int sampleType, 
+                                                                          VssRayContainer *outRays) const
+{
+        VssRayContainer passSamples;
+        SimpleRayContainer simpleRays;
+
+        preprocessor->GenerateRays(samplesPerPass,
+                                                           sampleType,
+                                                           simpleRays);
+
+        // shoot simple ray and add it to importance samples
+        preprocessor->CastRays(simpleRays, passSamples);
+
+        const int numSamples = (int)passSamples.size();
+
+        if (outRays)
+        {
+                while (!passSamples.empty())
+                        outRays->push_back(passSamples.back());
+        }
+        else
+        {
+                CLEAR_CONTAINER(passSamples);
+        }
+
+        return numSamples;
+}
+
+
 int ViewCellsManager::Construct(Preprocessor *preprocessor, VssRayContainer *outRays)
 {
+        int numSamples = 0;
         SimpleRayContainer simpleRays;
-        VssRayContainer constructionRays;
-
-        preprocessor->GenerateRays(mConstructionSamples,
-                                                           Preprocessor::SPATIAL_BOX_BASED_DISTRIBUTION,
-                                                           simpleRays);
-
-        Construct(preprocessor->mObjects, constructionRays);
-
-        int numRays = (int)simpleRays.size();
-
-        static Ray traversalRay;
-
-        // shoot simple ray and add it to construction rays
-        while (!simpleRays.empty())
-        {
-                SimpleRay sray = simpleRays.back();
-
-                // TODO: shoot into kdtree
-                constructionRays.push_back(new VssRay(traversalRay));
-
-                if (outRays)
-                        outRays->push_back(constructionRays.back());
-
-                simpleRays.pop_back();
-        }
-
-        if (!outRays)
-                CLEAR_CONTAINER(constructionRays);
-
-        // guided rays
-        VssRayContainer importanceRays;
-        const int desiredImportanceRays = max(1000000, mPostProcessSamples);
-        preprocessor->GenerateRays(desiredImportanceRays,
-                                                           Preprocessor::RSS_BASED_DISTRIBUTION,
-                                                           simpleRays);
-
-        numRays += (int)simpleRays.size();
-
-        // shoot simple ray and add it to construction rays
-        while (!simpleRays.empty())
-        {
-                SimpleRay sray = simpleRays.back();
-
-                // TODO: shoot into kdtree
-                importanceRays.push_back(new VssRay(traversalRay));
-
-                if (outRays)
-                        outRays->push_back(importanceRays.back());
-
-                simpleRays.pop_back();
-        }
-
-        if (!outRays)
-                CLEAR_CONTAINER(importanceRays);
-
+        
+        VssRayContainer constructionSamples;
+
+        //-- construction rays => we use uniform samples for this
+        CastPassSamples(mConstructionSamples, 
+                                        Preprocessor::SPATIAL_BOX_BASED_DISTRIBUTION, 
+                                        &constructionSamples);
+        
+        // construct view cells
+        const int initialSamples = Construct(preprocessor->mObjects, constructionSamples);
+
+        numSamples += initialSamples;
+
+        if (outRays)
+        {
+                while (!constructionSamples.empty())
+                        outRays->push_back(constructionSamples.back());
+        }
+        else
+        {
+                CLEAR_CONTAINER(constructionSamples);
+        }
+
+
+        //-- guided rays are used for further sampling
+        const int desiredImportanceSamples = 5000000;
+        const int importanceRayPerPass = 1000000;
+
+        const int n = desiredImportanceSamples; //+initialSamples;
+
+        while (numSamples < n)
+        {
+                numSamples += CastPassSamples(importanceRayPerPass, 
+                                                                          Preprocessor::RSS_BASED_DISTRIBUTION, 
+                                                                          //Preprocessor::SPATIAL_BOX_BASED_DISTRIBUTION,
+                                                                          outRays);
+        }
+        
+
+        //-- post processing
+        VssRayContainer postProcessSamples;
+
+        //-- construction rays => we use uniform samples for this
+        CastPassSamples(max(mPostProcessSamples, mVisualizationSamples),
+                                    Preprocessor::SPATIAL_BOX_BASED_DISTRIBUTION, 
+                                        &postProcessSamples);
+        
         // merge the view cells
-        PostProcess(preprocessor->mObjects, importanceRays);
-
-        Visualize(preprocessor->mObjects, importanceRays);
-
-
-        return numRays;
+        PostProcess(preprocessor->mObjects, postProcessSamples);
+        // several visualizations
+        Visualize(preprocessor->mObjects, postProcessSamples);
+
+        if (outRays)
+        {
+                while (!postProcessSamples.empty())
+                        outRays->push_back(postProcessSamples.back());
+        }
+        else
+        {
+                CLEAR_CONTAINER(postProcessSamples);
+        }
+
+        return numSamples;
 }
 

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.h

@@ -306 +306 @@
 protected:
 
+        int CastPassSamples(int samplesPerPass, 
+                                                int sampleType, 
+                                                VssRayContainer *outRays) const;
+
         void ParseEnvironment();
 

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp

@@ -942 +942 @@
                                 else
                                 {
-                                        nCostRatio[axis] = SplitPlaneCost(Plane3(normal, nPosition[axis]), 
-                                                                                                          tData, *nFrontGeom[axis], *nBackGeom[axis],
-                                                                                                          nProbFront[axis], nProbBack[axis]);
+                                        nCostRatio[axis] = 
+                                                EvalSplitPlaneCost(Plane3(normal, nPosition[axis]), 
+                                                                                   tData, *nFrontGeom[axis], *nBackGeom[axis],
+                                                                                   nProbFront[axis], nProbBack[axis]);
                                 }
                         }
@@ -1123 +1124 @@
                 float fArea, bArea;
                 plane = poly->GetSupportingPlane();
-                candidateCost = SplitPlaneCost(plane, data, fGeom, bGeom, fArea, bArea);
+                candidateCost = EvalSplitPlaneCost(plane, data, fGeom, bGeom, fArea, bArea);
                 
                 if (candidateCost < lowestCost)
@@ -1263 +1264 @@
 
 
-float VspBspTree::SplitPlaneCost(const Plane3 &candidatePlane,
-                                                                 const VspBspTraversalData &data,
-                                                                 BspNodeGeometry &geomFront,
-                                                                 BspNodeGeometry &geomBack,
-                                                                 float &pFront,
-                                                                 float &pBack) const
+float VspBspTree::EvalSplitPlaneCost(const Plane3 &candidatePlane,
+                                                                         const VspBspTraversalData &data,
+                                                                         BspNodeGeometry &geomFront,
+                                                                         BspNodeGeometry &geomBack,
+                                                                         float &pFront,
+                                                                         float &pBack) const
 {
         float cost = 0;
@@ -1377 +1378 @@
         if (mSplitPlaneStrategy & PVS)
         {
-                const float oldCost = pOverall * (float)totalPvs + Limits::Small;
-                cost += mPvsFactor * (pvsFront * pFront + pvsBack * pBack) / oldCost;
+                if (1)
+                {
+                        const float oldCost = pOverall * (float)totalPvs + Limits::Small;
+                        cost += mPvsFactor * (pvsFront * pFront + pvsBack * pBack) / oldCost;
+                }
+                else
+                {
+                        // try to equalize render differences
+                        const float oldCost = pOverall * (float)totalPvs + Limits::Small;
+                        float newCost = fabs(pvsFront * pFront - pvsBack * pBack);
+
+                        cost += mPvsFactor * newCost / oldCost;
+                }
         }
 
@@ -2573 +2585 @@
         }
 
+        // important so other merge candidates sharing this view cell
+        // are notified that the merge cost must be updated!!
         vc->Mail();
 
-        // clean up old view cells
+        //-- clean up old view cells
         if (mExportMergedViewCells)
         {
@@ -2581 +2595 @@
                 DEL_PTR(bVc);
         }
-        else // throw them into old view cells container
-        {
+        else 
+        {
+                // old view cells container needed for visualization
                 //fVc->mMailbox = -1;
                 //bVc->mMailbox = -1;
@@ -3204 +3219 @@
                 return 1e15f;
 
+#if 1
         float p1, p2;
 
@@ -3217 +3233 @@
         }
 
-        const float cost1 = (float)pvs1;// * p1;
-        const float cost2 = (float)pvs2;// * p2;
+        const float cost1 = pvs1 * p1;
+        const float cost2 = pvs2 * p2;
+#else
+        const float cost1 = pvs1;
+        const float cost2 = pvs2;
+#endif
 
         return cost1 + cost2;
@@ -3270 +3290 @@
         BspViewCell *vc2 = leaf2->GetViewCell();
 
-        float cost1 = vc1->GetPvs().GetSize(); 
-        float cost2 = vc2->GetPvs().GetSize(); 
-
-        /*if (mUseAreaForPvs)
+        float cost1, cost2;
+
+#if 1
+        if (mUseAreaForPvs)
         {
                 cost1 = vc1->GetPvs().GetSize() * vc1->GetArea();
@@ -3282 +3302 @@
                 cost1 = vc1->GetPvs().GetSize() * vc1->GetVolume();
                 cost2 = vc2->GetPvs().GetSize() * vc2->GetVolume();
-        }*/
+        }
+#else
+        cost1 = vc1->GetPvs().GetSize(); 
+        cost2 = vc2->GetPvs().GetSize(); 
+#endif
 
         const float oldCost = cost1 + cost2;

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.h

@@ -411 +411 @@
                 @returns the cost of the candidate split plane
         */
-        float SplitPlaneCost(const Plane3 &candidatePlane, 
-                                                 const VspBspTraversalData &data,
-                                                 BspNodeGeometry &geomFront,
-                                                 BspNodeGeometry &geomBack,
-                                                 float &pFront,
-                                                 float &pBack) const;
+        float EvalSplitPlaneCost(const Plane3 &candidatePlane, 
+                                                         const VspBspTraversalData &data,
+                                                         BspNodeGeometry &geomFront,
+                                                         BspNodeGeometry &geomBack,
+                                                         float &pFront,
+                                                         float &pBack) const;
 
         /** Subdivide leaf.