Changeset 1765

Timestamp:

11/18/06 23:15:55 (18 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/Lib/Vis/Preprocessing/src

Files:

• BvHierarchy.cpp (modified) (1 diff)
• BvHierarchy.h (modified) (1 diff)
• IntersectableWrapper.cpp (modified) (3 diffs)
• Preprocessor.cpp (modified) (4 diffs)
• Preprocessor.h (modified) (1 diff)
• RssPreprocessor.cpp (modified) (3 diffs)
• RssPreprocessor.h (modified) (1 diff)
• SamplingStrategy.cpp (modified) (3 diffs)
• ViewCellsManager.cpp (modified) (4 diffs)
• VspBspTree.cpp (modified) (2 diffs)
• VspTree.cpp (modified) (32 diffs)
• VspTree.h (modified) (7 diffs)

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

@@ -1542 +1542 @@
                         }
                 }
+
 #if COUNT_ORIGIN_OBJECTS
+
                 if (ray->mOriginObject)
                 {

GTP/trunk/Lib/Vis/Preprocessing/src/BvHierarchy.h

@@ -364 +364 @@
 public:
 
-        /// Rays piercing this leaf.
-        //VssRayContainer mVssRays;
         /// objects
         ObjectContainer mObjects;
-        /// universal counter
-        int mCounter;
 
 protected:

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

@@ -61 +61 @@
 {
         // random barycentric coordinates
-        float a = RandomValue(0,1);
-        float b = RandomValue(0,1);
-        float c = RandomValue(0,1);
+        float a = RandomValue(0.0f, 1.0f);
+        float b = RandomValue(0.0f, 1.0f);
+        float c = RandomValue(0.0f, 1.0f);
         
         const float sum = a + b + c;
@@ -95 +95 @@
                                                                                           Vector3 &normal)
 {
-        int edge = Random(3);
+        const int edge = Random(3);
 
-        Vector3 a = mItem.mVertices[edge];
-        Vector3 b = mItem.mVertices[(edge + 1) % 3];
+        const Vector3 a = mItem.mVertices[edge];
+        const Vector3 b = mItem.mVertices[(edge + 1) % 3];
 
         const float factor = RandomValue(0.0f, 1.0f);
@@ -112 +112 @@
   IntersectableWrapper<KdNode *>(item)
 {
-  mBox = box;
+        mBox = box;
 }
 }

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

@@ -934 +934 @@
 }
 
-bool Preprocessor::GenerateRays(const int number,
-                                                                const int sampleType,
-                                                                SimpleRayContainer &rays)
+int Preprocessor::GenerateRays(const int number,
+                                                           const int sampleType,
+                                                           SimpleRayContainer &rays)
 {
         const int startSize = (int)rays.size();
@@ -943 +943 @@
         if (!strategy)
         {
-                return false;
-        }
-
-        for (int i=0; (int)rays.size() - startSize < number; ++ i) 
+                return 0;
+        }
+
+        int castRays = 0;
+
+        for (int i = 0; (int)rays.size() - startSize < number; ++ i) 
         {
                 SimpleRay newRay;
@@ -954 +956 @@
 #if 1
                         rays.AddRay(newRay);
+                        ++ castRays;
 #else
                         GenerateRayBundle(rays, newRay, 16, 0);
+                        castRays += 16;
 #endif
                 }       
@@ -961 +965 @@
 
         delete strategy;
-    return true;
+    return castRays;
 }
 

GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.h

@@ -121 +121 @@
         bool ExportKdTree(const string filename);
 
-        virtual bool GenerateRays(const int number,
-                                                          const int raysType,
-                                                          SimpleRayContainer &rays);
+        virtual int GenerateRays(const int number,
+                                                         const int raysType,
+                                                         SimpleRayContainer &rays);
 
         bool GenerateRayBundle(SimpleRayContainer &rayBundle,

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

@@ -56 +56 @@
 
 
-bool
+int
 RssPreprocessor::GenerateRays(
                                                           const int number,
@@ -63 +63 @@
                                                           )
 {
-  bool result = false;
+  int result = 0;
   
   Debug<<"Generate rays...\n"<<flush;
@@ -71 +71 @@
   case SamplingStrategy::RSS_SILHOUETTE_BASED_DISTRIBUTION:
         if (mRssTree) {
-          GenerateImportanceRays(mRssTree, number, rays);
-          result = true;
+          result = GenerateImportanceRays(mRssTree, number, rays);
         }
         break;

GTP/trunk/Lib/Vis/Preprocessing/src/RssPreprocessor.h

@@ -133 +133 @@
 
   /** Redefininition of the get sample rays method from the preprocessor */
-  bool
+  int
   GenerateRays(
                            const int number,

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

@@ -166 +166 @@
 
         object->GetRandomSurfacePoint(point, normal);
+        
         direction = origin - point;
-
-        // $$ jb the pdf is yet not correct for all sampling methods!
-        const float c = Magnitude(direction);
-
-        if (c <= Limits::Small) 
-                return false;
+        
+        // $$ jb the pdf is yet not correct for all sampling methods!
+        const float c = Magnitude(direction);
+        
+        if ((c <= Limits::Small) || (DotProd(direction, normal) < 0))
+        {
+                return false;
+        }
 
         // $$ jb the pdf is yet not correct for all sampling methods!
@@ -178 +181 @@
         //cout << "p: " << point << " ";
         direction *= 1.0f / c;
+        // a little offset
+        point += direction * 0.01f;
+
         ray = SimpleRay(point, direction, pdf);
         
@@ -220 +226 @@
 }
 
+
 #if 0
 bool ObjectsInteriorDistribution::GenerateSample(SimpleRay &ray) const

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

@@ -316 +316 @@
 
         // create one third of each type
-        int stype;
-        
-        const int numStrategies = 3;
-
-        stype = SamplingStrategy::OBJECT_BASED_DISTRIBUTION;
-        mPreprocessor->GenerateRays(samplesPerPass / numStrategies, sampleType, simpleRays);
-        
-        stype = SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION;
-        mPreprocessor->GenerateRays(samplesPerPass / numStrategies, sampleType, simpleRays);
-        
-        if (0)
-        {
-                stype = SamplingStrategy::DIRECTION_BASED_DISTRIBUTION;
-                mPreprocessor->GenerateRays(samplesPerPass / numStrategies, sampleType, simpleRays);
-        }
-
-        stype = SamplingStrategy::REVERSE_OBJECT_BASED_DISTRIBUTION;
-        mPreprocessor->GenerateRays(samplesPerPass / numStrategies, sampleType, simpleRays);
+        int castRays = 0;
+        
+        vector<int> strategies;
+         
+        strategies.push_back(SamplingStrategy::OBJECT_BASED_DISTRIBUTION);
+        strategies.push_back(SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION);
+        strategies.push_back(SamplingStrategy::REVERSE_OBJECT_BASED_DISTRIBUTION);
+
+        const int numRaysPerPass = samplesPerPass / (int)strategies.size();
+
+        vector<int>::const_iterator iit, iit_end = strategies.end();
+
+        for (iit = strategies.begin(); iit != iit_end; ++ iit)
+        {
+                int stype = *iit;
+                const int newRays = 
+                        mPreprocessor->GenerateRays(numRaysPerPass, stype, simpleRays);
+        
+                cout << "cast " << newRays << " rays of strategy " << stype << endl;
+                castRays += newRays;
+        }
 
         cout << "generated " << samplesPerPass << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
@@ -2708 +2711 @@
                         if (vcValid)
                         {
-                                m.mDiffuseColor.r = 0.5f + RandomValue(0.0f, 0.5f);
-                                m.mDiffuseColor.g = 0.5f + RandomValue(0.0f, 0.5f);
-                                m.mDiffuseColor.b = 0.5f + RandomValue(0.f, 0.5f);
+                                m.mDiffuseColor.r = 0.2f + RandomValue(0.0f, 0.8f);
+                                m.mDiffuseColor.g = 0.2f + RandomValue(0.0f, 0.8f);
+                                m.mDiffuseColor.b = 0.2f + RandomValue(0.0f, 0.8f);
                         }
                         else
@@ -2753 +2756 @@
         // special color code for invalid view cells
         m.mDiffuseColor.r = importance;
-        m.mDiffuseColor.g = 1.0f - m.mDiffuseColor.r;
-        m.mDiffuseColor.b = vcValid ? 1.0f : 0.0f;
+        m.mDiffuseColor.g = vcValid ? 0.0f : 1.0f;
+        m.mDiffuseColor.b = 1.0f - importance;
 
         //Debug << "importance: " << importance << endl;
@@ -5435 +5438 @@
         Exporter *exporter = Exporter::GetExporter("final_view_cells.wrl");
 
-        Vector3 scale(1.0f, 0.9f, 1.0f);
+        Vector3 scale(0.9f, 0.9f, 0.9f);
         if (exporter)
         {

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

@@ -41 +41 @@
 
 // pvs penalty can be different from pvs size
-inline static float EvalPvsPenalty(const int pvs, 
-                                                                   const int lower,
-                                                                   const int upper)
+inline static float EvalPvsPenalty(const float pvs, 
+                                                                   const float lower,
+                                                                   const float upper)
 {
         // clamp to minmax values
@@ -2267 +2267 @@
                 AddObjToPvs((*rit).mRay->mTerminationObject, side, pvsFront, pvsBack, pvsTotal);
 
-                if (COUNT_ORIGIN_OBJECTS) 
+                if (COUNT_ORIGIN_OBJECTS)
+                {
                         AddObjToPvs((*rit).mRay->mOriginObject, side, pvsFront, pvsBack, pvsTotal);
+                }
         }
 

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

@@ -40 +40 @@
 
 // pvs penalty can be different from pvs size
-inline static float EvalPvsPenalty(const int pvs, 
-                                                                   const int lower,
-                                                                   const int upper)
+inline static float EvalPvsPenalty(const float pvs, 
+                                                                   const float lower,
+                                                                   const float upper)
 {
         // clamp to minmax values
@@ -734 +734 @@
                         
                 mTotalCost -= sc->GetRenderCostDecrease();
-                mTotalPvsSize += tFrontData.mPvs + tBackData.mPvs - tData.mPvs;
+                mTotalPvsSize += (int)(tFrontData.mPvs + tBackData.mPvs - tData.mPvs);
                 mPvsEntries += sc->GetPvsEntriesIncr();
 
@@ -932 +932 @@
 
         //-- compute pvs
-        frontData.mPvs = EvalPvsSize(*frontData.mRays);
-        backData.mPvs = EvalPvsSize(*backData.mRays);
+        frontData.mPvs = EvalPvsCost(*frontData.mRays);
+        backData.mPvs = EvalPvsCost(*backData.mRays);
                 
         //-- split front and back node geometry and compute area
@@ -1120 +1120 @@
 
 
-int VspTree::PrepareHeuristics(KdLeaf *leaf)
+float VspTree::PrepareHeuristics(KdLeaf *leaf)
 {       
-        int pvsSize = 0;
+        float pvsSize = 0;
         
         if (!leaf->Mailed())
@@ -1160 +1160 @@
 
 
-int VspTree::PrepareHeuristics(const RayInfoContainer &rays)
+float VspTree::PrepareHeuristics(const RayInfoContainer &rays)
 {       
         Intersectable::NewMail();
@@ -1166 +1166 @@
         BvhLeaf::NewMail();
 
-        int pvsSize = 0;
+        float pvsSize = 0;
 
         RayInfoContainer::const_iterator ri, ri_end = rays.end();
@@ -1243 +1243 @@
 
 void VspTree::EvalHeuristics(const SortableEntry &ci,
-                                                         int &pvsLeft,
-                                                         int &pvsRight) const
+                                                         float &pvsLeft,
+                                                         float &pvsRight) const
 {
         VssRay *ray = ci.ray;
@@ -1251 +1251 @@
         if (ci.type == SortableEntry::ERayMin)
         {
+                pvsLeft += EvalMinEventContribution(*ray, true);
 #if COUNT_ORIGIN_OBJECTS
-                pvsLeft += EvalMinEventContribution(*ray, true);
-#else
                 pvsLeft += EvalMinEventContribution(*ray, false);
 #endif
@@ -1259 +1258 @@
         else // eval changes in pvs causes by max event 
         {
+                pvsRight -= EvalMaxEventContribution(*ray, true);
 #if COUNT_ORIGIN_OBJECTS
-                pvsRight -= EvalMaxEventContribution(*ray, true);
-#else
                 pvsRight -= EvalMaxEventContribution(*ray, false);
 #endif
@@ -1271 +1269 @@
                                                                            const AxisAlignedBox3 &box,
                                                                            const int axis,
-                                                                           float &position)
-{
-        // get subset of rays
-        RayInfoContainer randomRays;
-        randomRays.reserve(mMaxTests);
-
-        RayInfoContainer *usedRays;
-
-        if (mMaxTests < (int)tData.mRays->size())
-        {
-                GetRayInfoSets(*tData.mRays, mMaxTests, randomRays);
-                usedRays = &randomRays;
-        }
-        else
-        {
-                usedRays = tData.mRays;
-        }
-
+                                                                           float &position,
+                                                                           const RayInfoContainer &usedRays)
+{
         const float minBox = box.Min(axis);
         const float maxBox = box.Max(axis);
@@ -1297 +1280 @@
         const float maxBand = minBox + mMaxBand * sizeBox;
 
-        SortSubdivisionCandidates(*usedRays, axis, minBand, maxBand);
+        SortSubdivisionCandidates(usedRays, axis, minBand, maxBand);
 
         // prepare the sweep
         // note: returns pvs size => no need t give pvs size as function parameter
-        const int pvsSize = PrepareHeuristics(*usedRays);
+        const float pvsCost = PrepareHeuristics(usedRays);
 
         // go through the lists, count the number of objects left and right
@@ -1307 +1290 @@
         // C = ct_div_ci  + (ql*rl + qr*rr)/queries
 
-        int pvsl = 0;
-        int pvsr = pvsSize;
-
-        int pvsBack = pvsl;
-        int pvsFront = pvsr;
-
-        float sum = (float)pvsSize * sizeBox;
+        float pvsl = 0;
+        float pvsr = pvsCost;
+
+        float pvsBack = pvsl;
+        float pvsFront = pvsr;
+
+        float sum = pvsCost * sizeBox;
         float minSum = 1e20f;
 
@@ -1327 +1310 @@
         BvhLeaf::NewMail();
 
-        //-- traverse through visibility events
-        vector<SortableEntry>::const_iterator ci, ci_end = mLocalSubdivisionCandidates->end();
-
-#ifdef GTPGTP_DEBUG
-        const float volRatio = tData.mBoundingBox.GetVolume() / (sizeBox * mBoundingBox.GetVolume());
+        const float volRatio = 
+                tData.mBoundingBox.GetVolume() / (sizeBox * mBoundingBox.GetVolume());
+
+        ////////
+        //-- iterate through visibility events
+
+        vector<SortableEntry>::const_iterator ci, 
+                ci_end = mLocalSubdivisionCandidates->end();
+
+#ifdef GTP_DEBUG
         const int leaves = mVspStats.Leaves();
         const bool printStats = ((axis == 0) && (leaves > 0) && (leaves < 90));
@@ -1370 +1358 @@
                         sum = pvsl * ((*ci).value - minBox) + pvsr * (maxBox - (*ci).value);
                         
-#ifdef GTPGTP_DEBUG
+#ifdef GTP_DEBUG
                         if (printStats)
                         {
@@ -1404 +1392 @@
         //-- compute cost
 
-        const int lowerPvsLimit = mViewCellsManager->GetMinPvsSize();
-        const int upperPvsLimit = mViewCellsManager->GetMaxPvsSize();
+        const float lowerPvsLimit = (float)mViewCellsManager->GetMinPvsSize();
+        const float upperPvsLimit = (float)mViewCellsManager->GetMaxPvsSize();
 
         const float pOverall = sizeBox;
@@ -1411 +1399 @@
         const float pFront = maxBox - position;
 
-        const float penaltyOld = EvalPvsPenalty(pvsSize, lowerPvsLimit, upperPvsLimit);
+        const float penaltyOld = EvalPvsPenalty(pvsCost, lowerPvsLimit, upperPvsLimit);
     const float penaltyFront = EvalPvsPenalty(pvsFront, lowerPvsLimit, upperPvsLimit);
         const float penaltyBack = EvalPvsPenalty(pvsBack, lowerPvsLimit, upperPvsLimit);
@@ -1423 +1411 @@
         }
         
-#ifdef GTPGTP_DEBUG
-        Debug << "\n§§§§ eval local cost §§§§" << endl
+//#ifdef GTP_DEBUG
+        cout << "\n((((( eval local cost )))))" << endl
                   << "back pvs: " << penaltyBack << " front pvs: " << penaltyFront << " total pvs: " << penaltyOld << endl 
                   << "back p: " << pBack * volRatio << " front p " << pFront * volRatio << " p: " << pOverall * volRatio << endl
                   << "old rc: " << oldRenderCost * volRatio << " new rc: " << newRenderCost * volRatio << endl
                   << "render cost decrease: " << oldRenderCost * volRatio - newRenderCost * volRatio << endl;
-#endif
+//#endif
         return ratio;
 }
@@ -1454 +1442 @@
                 mOnlyDrivingAxis || mCirculatingAxis;
         
+        // get subset of rays
+        RayInfoContainer randomRays;
+        randomRays.reserve(mMaxTests);
+
+        RayInfoContainer *usedRays;
+
+        if (mMaxTests < (int)tData.mRays->size())
+        {
+                GetRayInfoSets(*tData.mRays, mMaxTests, randomRays);
+                usedRays = &randomRays;
+        }
+        else
+        {
+                usedRays = tData.mRays;
+        }
+
         if (mCirculatingAxis)
         {
@@ -1460 +1464 @@
 
                 if (parent)
+                {
                         parentAxis = dynamic_cast<VspInterior *>(parent)->GetAxis();
+                }
 
                 sAxis = (parentAxis + 1) % 3;
@@ -1476 +1482 @@
                         {
                                 //-- place split plane using heuristics
+
                                 nCostRatio[axis] =
                                         EvalLocalCostHeuristics(tData,
                                                                                         box,
                                                                                         axis,
-                                                                                        nPosition[axis]);                       
+                                                                                        nPosition[axis],
+                                                                                        *usedRays);                     
                         }
                         else
                         {
                                 //-- split plane position is spatial median                             
+                                
                                 nPosition[axis] = (box.Min()[axis] + box.Max()[axis]) * 0.5f;
                                 nCostRatio[axis] = EvalLocalSplitCost(tData,
@@ -1505 +1514 @@
         }
 
-        ////////////////////////////////
+        /////////////////////////
         //-- assign values of best split
 
@@ -1571 +1580 @@
 
 
-        ////////////////////////////////////
+        ///////////////////
         //-- evaluate render cost heuristics
 
-        const int lowerPvsLimit = mViewCellsManager->GetMinPvsSize();
-        const int upperPvsLimit = mViewCellsManager->GetMaxPvsSize();
-
-        const float penaltyOld = EvalPvsPenalty((int)totalPvs, lowerPvsLimit, upperPvsLimit);
-    const float penaltyFront = EvalPvsPenalty((int)pvsFront, lowerPvsLimit, upperPvsLimit);
-        const float penaltyBack = EvalPvsPenalty((int)pvsBack, lowerPvsLimit, upperPvsLimit);
+        const float lowerPvsLimit = (float)mViewCellsManager->GetMinPvsSize();
+        const float upperPvsLimit = (float)mViewCellsManager->GetMaxPvsSize();
+
+        const float penaltyOld = EvalPvsPenalty(totalPvs, lowerPvsLimit, upperPvsLimit);
+    const float penaltyFront = EvalPvsPenalty(pvsFront, lowerPvsLimit, upperPvsLimit);
+        const float penaltyBack = EvalPvsPenalty(pvsBack, lowerPvsLimit, upperPvsLimit);
                         
         const float oldRenderCost = pOverall * penaltyOld;
@@ -1590 +1599 @@
         const float renderCostDecrease = (oldRenderCost - newRenderCost) / viewSpaceVol;
 
-#ifdef GTPGTP_DEBUG
+#ifdef GTP_DEBUG
         Debug << "\nvsp render cost decrease" << endl
                   << "back pvs: " << pvsBack << " front pvs " << pvsFront << " total pvs: " << totalPvs << endl 
@@ -1619 +1628 @@
         KdLeaf::NewMail(3);
 
-        const int pvsSize = data.mPvs;
+        const float pvsSize = data.mPvs;
         RayInfoContainer::const_iterator rit, rit_end = data.mRays->end();
 
@@ -1863 +1872 @@
         if (data.mPvs > mVspStats.maxPvs)
         {
-                mVspStats.maxPvs = data.mPvs;
-        }
-
-        mVspStats.pvs += data.mPvs;
+                mVspStats.maxPvs = (int)data.mPvs;
+        }
+
+        mVspStats.pvs += (int)data.mPvs;
 
         if (data.mDepth < mVspStats.minDepth)
@@ -2215 +2224 @@
 
 
-int VspTree::EvalPvsSize(const RayInfoContainer &rays) const
-{
-        int pvsSize = 0;
+float VspTree::EvalPvsCost(const RayInfoContainer &rays) const
+{
+        float pvsCost = 0;
         
         Intersectable::NewMail();
@@ -2228 +2237 @@
         {
                 VssRay *ray = (*rit).mRay;
+                
+                pvsCost += EvalContributionToPvs(*ray, true);
+
 #if COUNT_ORIGIN_OBJECTS
-                pvsSize += EvalContributionToPvs(*ray, true);
-#else
-                pvsSize += EvalContributionToPvs(*ray, false);
+                pvsCost += EvalContributionToPvs(*ray, false);
 #endif
         }
         
-        return pvsSize;
+        return pvsCost;
 }
 
@@ -2307 +2317 @@
         {
                 VssRay *ray = (*rit).mRay;
+
+                pvsSize += EvalPvsEntriesContribution(*ray, true);
+
 #if COUNT_ORIGIN_OBJECTS
-                pvsSize += EvalPvsEntriesContribution(*ray, true);
-#else
                 pvsSize += EvalPvsEntriesContribution(*ray, false);
 #endif
@@ -2890 +2901 @@
 
         /// collect pvs from rays
-        const int pvsSize = EvalPvsSize(rays);
+        const float pvsCost = EvalPvsCost(rays);
         
         // root and bounding box were already constructed
@@ -2901 +2912 @@
         
         // first vsp traversal data
-        VspTraversalData vData(leaf, 0, &rays, pvsSize, prop, mBoundingBox);
+        VspTraversalData vData(leaf, 0, &rays, pvsCost, prop, mBoundingBox);
 
 
@@ -2923 +2934 @@
         leaf->SetSubdivisionCandidate(splitCandidate);
 
-        mTotalCost = (float)pvsSize;
+        mTotalCost = pvsCost;
         mPvsEntries = EvalPvsEntriesSize(rays);
 
@@ -3057 +3068 @@
 
 
-int VspTree::PrepareHeuristics(const VssRay &ray, const bool isTermination)
-{
-        int pvsSize = 0;
+float VspTree::PrepareHeuristics(const VssRay &ray, const bool isTermination)
+{
+        float pvsSize = 0;
         
         Intersectable *obj;

GTP/trunk/Lib/Vis/Preprocessing/src/VspTree.h

@@ -384 +384 @@
                                                  const int depth, 
                                                  RayInfoContainer *rays,
-                                                 const int pvs,
+                                                 const float pvs,
                                                  const float p,
                                                  const AxisAlignedBox3 &box):
@@ -441 +441 @@
                 AxisAlignedBox3 mBoundingBox;
                 /// pvs size
-                int mPvs;
+                float mPvs;
                 /// how often this branch has missed the max-cost ratio
                 int mMaxCostMisses;
@@ -817 +817 @@
                                                          float maxBand);
 
-        /** Evaluate pvs size as induced by the samples.
-        */
-        int EvalPvsSize(const RayInfoContainer &rays) const;
+        /** Evaluate render cost of this pvs.
+        */
+        float EvalPvsCost(const RayInfoContainer &rays) const;
 
         int EvalPvsEntriesIncr(VspSubdivisionCandidate &splitCandidate) const;
@@ -826 +826 @@
         */
         int EvalPvsEntriesSize(const RayInfoContainer &rays) const;
+
         int EvalPvsEntriesContribution(const VssRay &ray, const bool isTermination) const;
+
         /** Computes best cost for axis aligned planes.
         */
@@ -832 +834 @@
                                                                   const AxisAlignedBox3 &box,
                                                                   const int axis,
-                                                                  float &position);
+                                                                  float &position,
+                                                                  const RayInfoContainer &usedRays);
 
 
@@ -843 +846 @@
                 @param rightPvs updates the right pvs
         */
-        void EvalHeuristics(const SortableEntry &ve, int &pvsLeft, int &pvsRight) const;
+        void EvalHeuristics(const SortableEntry &ve, float &pvsLeft, float &pvsRight) const;
 
         /** Evaluates contribution of min event to pvs
@@ -865 +868 @@
                 @returns pvs size as seen by the rays.
         */
-        int PrepareHeuristics(const RayInfoContainer &rays);
+        float PrepareHeuristics(const RayInfoContainer &rays);
         
         /** Prepare a single ray for heuristics.
         */
-        int PrepareHeuristics(const VssRay &ray, const bool isTermination);
+        float PrepareHeuristics(const VssRay &ray, const bool isTermination);
+
         /** Prepare a single kd leaf for heuristics.
         */
-        int PrepareHeuristics(KdLeaf *leaf);
+        float PrepareHeuristics(KdLeaf *leaf);