Changeset 1121 for GTP/trunk/Lib/Vis/Preprocessing/src/VspOspTree.cpp

Timestamp:

07/12/06 00:52:51 (18 years ago)

Author:

mattausch

Message:

 

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/VspOspTree.cpp (modified) (49 diffs)

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

@@ -22 +22 @@
 
 #define USE_FIXEDPOINT_T 0
-#define COUNT_OBJECTS 1
+#define COUNT_OBJECTS 0
 
 //-- static members
@@ -50 +50 @@
 void VspTreeStatistics::Print(ostream &app) const
 {
-        app << "===== VspTree statistics ===============\n";
+        app << "=========== VspTree statistics ===============\n";
 
         app << setprecision(4);
@@ -99 +99 @@
         //app << "#N_PVS: " << pvs << endl;
 
-        app << "===== END OF VspTree statistics ==========\n";
+        app << "========== END OF VspTree statistics ==========\n";
 }
 
@@ -352 +352 @@
         //-- partition criteria
         Environment::GetSingleton()->GetFloatValue("VspTree.Construction.epsilon", mEpsilon);
+        Environment::GetSingleton()->GetFloatValue("VspTree.Construction.renderCostDecreaseWeight", mRenderCostDecreaseWeight);
 
         // if only the driving axis is used for axis aligned split
@@ -392 +393 @@
         Debug << "use cost heuristics: " << mUseCostHeuristics << endl;
         Debug << "subdivision stats log: " << subdivisionStatsLog << endl;
-        
+        Debug << "render cost decrease weight: " << mRenderCostDecreaseWeight << endl;
+
         Debug << "circulating axis: " << mCirculatingAxis << endl;
         Debug << "minband: " << mMinBand << endl;
@@ -598 +600 @@
                 tBackData.mMaxCostMisses = maxCostMisses;
                         
-                
+        
                 if (1)
                 {
@@ -620 +622 @@
                 }
 
-        
+
                 //-- evaluate new split candidates for global greedy cost heuristics
                 VspSplitCandidate *frontCandidate = new VspSplitCandidate(tFrontData);
@@ -630 +632 @@
                 tQueue.Push(frontCandidate);
                 tQueue.Push(backCandidate);
-
+                
+                // delete old view cell
+                delete tData.mNode->GetViewCell();
                 // delete old leaf node
                 DEL_PTR(tData.mNode);
@@ -747 +751 @@
                 parent->ReplaceChildLink(leaf, interior);
                 interior->SetParent(parent);
+
+                // remove "parent" view cell from pvs of all objects (traverse trough rays)
+                RemoveParentViewCellReferences(tData.mNode->GetViewCell());
         }
         else // new root
@@ -770 +777 @@
         CreateViewCell(backData);
 
-        // TODO: 
+        
         // create front and back view cell
-        // remove "parent" view cell from pvs of all objects (traverse trough rays)
         // add front and back view cell to "Potentially Visbilie View Cells" 
         // of the objects in front and back pvs
-        RemoveParentViewCellReferences(tData.mNode->GetViewCell());
         AddViewCellReferences(frontLeaf->GetViewCell());
         AddViewCellReferences(backLeaf->GetViewCell());
-
 
         interior->mTimeStamp = mTimeStamp ++;
@@ -1144 +1148 @@
 void VspTree::AddContriToPvs(KdLeaf *leaf, int &pvs) const
 {
-        if (!leaf->Mailed())
-        {
-                leaf->Mail();
-
-                // add objects without those which are part of several kd leaves
-                pvs += ((int)leaf->mObjects.size() - (int)leaf->mMultipleObjects.size());
-
-                //-- handle objects of several kd leaves separately
-                ObjectContainer::const_iterator oit, oit_end = leaf->mMultipleObjects.end();
-
-                for (oit = leaf->mMultipleObjects.begin(); oit != oit_end; ++ oit)
-                {
-                        Intersectable *object = *oit;
-
-                        // object not previously in left pvs
-                        if (!object->Mailed())
-                        {
-                                object->Mail();
-                                ++ pvs;
-                        }
+        if (leaf->Mailed())
+                return;
+        
+        leaf->Mail();
+
+        // add objects without those which are part of several kd leaves
+        pvs += ((int)leaf->mObjects.size() - (int)leaf->mMultipleObjects.size());
+
+        //-- handle objects of several kd leaves separately
+        ObjectContainer::const_iterator oit, oit_end = leaf->mMultipleObjects.end();
+
+        for (oit = leaf->mMultipleObjects.begin(); oit != oit_end; ++ oit)
+        {
+                Intersectable *object = *oit;
+
+                // object not previously in left pvs
+                if (!object->Mailed())
+                {
+                        object->Mail();
+                        ++ pvs;
                 }
         }                                       
@@ -1513 +1517 @@
         // take render cost of node into account 
         // otherwise danger of being stuck in a local minimum!!
-        const float factor = 0.99f;
+        const float factor = mRenderCostDecreaseWeight;
 
         const float normalizedOldRenderCost = oldRenderCost / mBoundingBox.GetVolume();
@@ -2554 +2558 @@
 
 
-
-
 int VspTree::ComputeBoxIntersections(const AxisAlignedBox3 &box,
                                                                          ViewCellContainer &viewCells) const
@@ -2606 +2608 @@
 
 
+
+void VspTree::CollectDirtyCandidates(VspSplitCandidate *sc, 
+                                                                         vector<SplitCandidate *> &dirtyList)
+{
+        VspLeaf *node = sc->mParentData.mNode;
+        
+    ViewCellLeaf *vc = node->GetViewCell();
+                
+        ObjectPvsMap::const_iterator oit, oit_end = vc->GetPvs().mEntries.end();
+
+        KdLeaf::NewMail();
+
+        for (oit = vc->GetPvs().mEntries.begin(); oit != oit_end; ++ oit)
+        {
+                Intersectable *obj = (*oit).first;
+
+                set<KdLeaf *>::const_iterator kit, kit_end = obj->mKdLeaves.end();
+
+                for (kit = obj->mKdLeaves.begin(); kit != kit_end; ++ kit)
+                {
+                        KdLeaf *leaf = *kit;
+
+                        if (!leaf->Mailed())
+                        {
+                                leaf->Mail();
+                                dirtyList.push_back(leaf->mSplitCandidate);
+                        }
+                }
+        }
+}
+
+
 /*****************************************************************/
 /*                class OspTree implementation                   */
@@ -2655 +2689 @@
 
         Environment::GetSingleton()->GetFloatValue("OspTree.Construction.splitBorder", mSplitBorder);
-        //mSplitBorder = 0.1f;
-
-
+        Environment::GetSingleton()->GetFloatValue("OspTree.Construction.renderCostDecreaseWeight", mRenderCostDecreaseWeight);
+        
         //-- debug output
 
@@ -2679 +2712 @@
         
         Debug << "split borders: " << mSplitBorder << endl;
+        Debug << "render cost decrease weight: " << mRenderCostDecreaseWeight << endl;
 
 
@@ -2761 +2795 @@
                 const AxisAlignedBox3 box = (*mi)->GetBox();
                 
-                if (box.Max(axis) > position) 
+                if (box.Max(axis) > position + mEpsilon) 
                         ++ objectsFront;
     
-                if (box.Min(axis) < position)
+                if (box.Min(axis) < position - mEpsilon)
                         ++ objectsBack;
         }
@@ -2843 +2877 @@
                 // delete old leaf node
                 DEL_PTR(tData.mNode);
-                DEL_PTR(tData.mNode->mViewCell);
         }
 
@@ -2892 +2925 @@
 {
         // matt: TODO
-        Debug << "here888 " << mTermMaxLeaves << " " << mOspStats.Leaves() << endl;
         return (
                 (mOspStats.Leaves() >= mTermMaxLeaves)
@@ -2952 +2984 @@
                                                                            int &objectsBack)
 {
-        
+        // sort so we can use a sweep
         SortSplitCandidates(node, axis);
   
@@ -2984 +3016 @@
 
         float sum = (float)pvsSize * sizeBox;
+float dummy1 = 0;
+float dummy2 = 0;
 
         vector<SortableEntry>::const_iterator ci, ci_end = mSplitCandidates->end();
-
+cout << "***********" << endl;
         //-- traverse through visibility events
         for (ci = mSplitCandidates->begin(); ci != ci_end; ++ ci)
         {
+                int pvslold = pvsl;
                 EvalPvsIncr(*ci, pvsl, pvsr);
+
+                cout << "incr: " << ci->mObject->mViewCellPvs.GetSize() << " obj id " 
+                         << ci->mObject->GetId() << endl;
 
                 // Note: sufficient to compare size of bounding boxes of front and back side?
@@ -2997 +3035 @@
                         sum = pvsl * ((*ci).value - minBox) + pvsr * (maxBox - (*ci).value);
 
-                        //Debug  << "pos=" << (*ci).value << "\t pvs=(" <<  pvsl << "," << pvsr << ")" << "\t cost= " << sum << endl;
+                        cout << "pos=" << (*ci).value << "\t pvs=(" <<  pvsl << "," 
+                                 << pvsr << ")" << "\t cost= " << sum << endl;
 
                         if (sum < minSum)
@@ -3012 +3051 @@
         }
         
-        
-        // -- compute cost
+        //-- compute cost
 
         const int lowerPvsLimit = mViewCellsManager->GetMinPvsSize();
@@ -3035 +3073 @@
         
         //if (axis != 1)
-        Debug << "axis=" << axis << " costRatio=" << ratio << " pos=" << position << " t=" << (position - minBox) / (maxBox - minBox)
-              <<"\t pb=(" << pvsBack << ")\t pf=(" << pvsFront << ")" << endl;
+        Debug << "axis=" << axis << " costRatio=" << ratio << " pos=" 
+                  << position << " t=" << (position - minBox) / (maxBox - minBox)
+              << "\t pb=(" << pvsBack << ")\t pf=(" << pvsFront << ")" << endl;
 
         return ratio;
 }
 
+
 void OspTree::SortSplitCandidates(KdLeaf *node, const int axis)
 {
         mSplitCandidates->clear();
 
-        int requestedSize = 2*(int)node->mObjects.size();
+        int requestedSize = 2 * (int)node->mObjects.size();
         
         // creates a sorted split candidates array
@@ -3074 +3114 @@
         stable_sort(mSplitCandidates->begin(), mSplitCandidates->end());
 }
-
 
 
@@ -3085 +3124 @@
         return object->mViewCellPvs.GetSize();
 #endif
+}
+
+
+const OspTreeStatistics &OspTree::GetStatistics() const
+{
+        return mOspStats;
 }
 
@@ -3124 +3169 @@
                         break;
         }
+
+        cout << "pvs left: " << pvsLeft << " pvs right " << pvsRight << endl;
 }
 
@@ -3241 +3288 @@
 float OspTree::EvalViewCellPvsIncr(Intersectable *object) const
 {
-        // TODO         
+#if COUNT_OBJECTS       
         return 1;
+#else
+        return (float)object->mViewCellPvs.GetSize();
+#endif
 }
 
@@ -3276 +3326 @@
                 const float pvsIncr = EvalViewCellPvsIncr(obj);
                 totalPvs += pvsIncr;
+                cout << "totalpvs " << totalPvs << " incr " << pvsIncr << endl;
 
                 if (box.Max(candidatePlane.mAxis) > candidatePlane.mPosition)
@@ -3310 +3361 @@
         const float newRenderCost = penaltyFront * pFront + penaltyBack * pBack;
 
-        Debug << "old: " << oldRenderCost << " new: " << newRenderCost << " decrease: " << oldRenderCost - newRenderCost << endl;
+        Debug << "old: " << oldRenderCost << " new: " << newRenderCost << " decrease: " 
+                << oldRenderCost - newRenderCost << endl;
         const float renderCostDecrease = (oldRenderCost - newRenderCost) / mBoundingBox.GetVolume();
         
         // take render cost of node into account 
         // otherwise danger of being stuck in a local minimum!!
-        const float factor = 0.99f;
+        const float factor = mRenderCostDecreaseWeight;
 
         const float normalizedOldRenderCost = oldRenderCost / mBoundingBox.GetVolume();
-
         return factor * renderCostDecrease + (1.0f - factor) * normalizedOldRenderCost;
 }
@@ -3429 +3480 @@
 
 
+void OspTree::CollectViewCells(KdLeaf *leaf, ViewCellContainer &viewCells)
+{
+        ObjectContainer::const_iterator oit, oit_end = leaf->mObjects.end();
+
+        ViewCell::NewMail();
+
+        // loop through all object and collect view cell pvs of this node
+        for (oit = leaf->mObjects.begin(); oit != oit_end; ++ oit)
+        {
+                Intersectable *obj = *oit;
+
+                ViewCellPvsMap::const_iterator vit, vit_end = obj->mViewCellPvs.mEntries.end();
+
+                for (vit = obj->mViewCellPvs.mEntries.begin(); vit != vit_end; ++ vit)
+                {
+            ViewCell *vc = (*vit).first;
+
+                        if (!vc->Mailed())
+                        {
+                                vc->Mail();
+                                viewCells.push_back(vc);
+                        }
+                }
+        }
+
+}
+
+
+void OspTree::CollectDirtyCandidates(OspSplitCandidate *sc, 
+                                                                         vector<SplitCandidate *> &dirtyList)
+{
+        KdLeaf *node = sc->mParentData.mNode;
+
+        ObjectContainer::const_iterator oit, oit_end = node->mObjects.end();
+
+        ViewCellContainer viewCells;
+
+        CollectViewCells(node, viewCells);
+
+        ViewCellContainer::const_iterator vit, vit_end = viewCells.end();
+
+        // through split candidates corresponding to view cell pvs of this
+        // node into dirty list
+        for (vit = viewCells.begin(); vit != vit_end; ++ vit)
+        {
+                VspViewCell *vc = dynamic_cast<VspViewCell *>(*vit);
+
+                VspLeaf *leaf = vc->mLeaf;
+                dirtyList.push_back(leaf->GetSplitCandidate());
+        }
+}
+
+
+int OspTree::ComputePvsSize(const ObjectContainer &objects) const
+{
+        int pvsSize = 0;
+
+        ObjectContainer::const_iterator oit, oit_end = objects.end();
+
+        for (oit = objects.begin(); oit != oit_end; ++ oit)
+        {
+                pvsSize += (*oit)->mViewCellPvs.GetSize();
+        }
+
+        return pvsSize;
+}
+
+
 /********************************************************************/
 /*               class HierarchyManager implementation              */
@@ -3445 +3564 @@
         SplitCandidate *splitCandidate = mTQueue.Top();
 
-        Debug << "next candidate: " << splitCandidate->Type()
+        cout << "next candidate: " << splitCandidate->Type()
                 << ", priority: " << splitCandidate->GetPriority() << endl;
 
@@ -3454 +3573 @@
 
 
-void HierarchyManager::PrepareConstruction(const VssRayContainer &sampleRays,
-                                                                                   const ObjectContainer &objects,
-                                                                                   AxisAlignedBox3 *forcedViewSpace,
-                                                                                   RayInfoContainer &rays)
-{
-        mVspTree.PrepareConstruction(sampleRays, forcedViewSpace);
+void HierarchyManager::ProcessRays(const VssRayContainer &sampleRays,
+                                                                   RayInfoContainer &rays,
+                                                                   ObjectContainer &sampledObjects)
+{
+        VssRayContainer::const_iterator rit, rit_end = sampleRays.end();
 
         long startTime = GetTime();
@@ -3467 +3585 @@
         Intersectable::NewMail();
 
-        VssRayContainer::const_iterator rit, rit_end = sampleRays.end();
-
-        //-- store rays
+        //-- store rays and objects
         for (rit = sampleRays.begin(); rit != rit_end; ++ rit)
         {
                 VssRay *ray = *rit;
-
                 float minT, maxT;
-
                 static Ray hray;
+
                 hray.Init(*ray);
                 
@@ -3489 +3604 @@
                         rays.push_back(RayInfo(ray, minT / len, maxT / len));
                 }
+
+                // store objects
+                if (ray->mTerminationObject && !ray->mTerminationObject->Mailed())
+                {
+                        ray->mTerminationObject->Mail();
+                        sampledObjects.push_back(ray->mTerminationObject);
+                }
+
+                if (ray->mOriginObject && !ray->mOriginObject->Mailed())
+                {
+                        ray->mOriginObject->Mail();
+                        sampledObjects.push_back(ray->mOriginObject);
+                }
         }
 
         cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-
-
-        int pvsSize = mVspTree.ComputePvsSize(rays);
-
+}
+
+
+void HierarchyManager::PrepareVsp(const VssRayContainer &sampleRays,
+                                                                  AxisAlignedBox3 *forcedViewSpace,
+                                                                  RayInfoContainer &rays)
+{
+        // prepare bounding box
+        mVspTree.PrepareConstruction(sampleRays, forcedViewSpace);
+
+        // get clipped rays
+        ObjectContainer sampledObjects;
+        ProcessRays(sampleRays, rays, sampledObjects);
+
+        //const int pvsSize = mVspTree.ComputePvsSize(rays);
+        const int pvsSize = (int)sampledObjects.size();
+
+        cout <<  "here450 pvs size: " << pvsSize << endl;
         // -- prepare view space partition
 
@@ -3507 +3649 @@
                                                                         0,
                                                                         &rays,
-                                                                        //(int)objects.size(),
                                                                         pvsSize,        
                                                                         prop,
@@ -3513 +3654 @@
 
 
+        // create first view cell
+        mVspTree.CreateViewCell(vData);
+                
+        // add first view cell to all the objects view cell pvs
+        ObjectPvsMap::const_iterator oit, 
+                oit_end = leaf->GetViewCell()->GetPvs().mEntries.end();
+
+        cout << "here23 " << leaf->GetViewCell()->GetPvs().mEntries.size();
+
+        for (oit = leaf->GetViewCell()->GetPvs().mEntries.begin(); oit != oit_end; ++ oit)
+        {
+                Intersectable *obj = (*oit).first;
+                cout << "obj: " << obj->GetId() << endl;
+                obj->mViewCellPvs.AddSample(leaf->GetViewCell(), 1);
+        }
+
         // compute first split candidate
         VspTree::VspSplitCandidate *splitCandidate = new VspTree::VspSplitCandidate(vData);
@@ -3518 +3675 @@
 
         mTQueue.Push(splitCandidate);
-
-
-        //-- object space partition
-
+}
+
+
+void HierarchyManager::PrepareOsp(const ObjectContainer &objects,                                                                                 
+                                                                  AxisAlignedBox3 *forcedViewSpace)
+{
         mOspTree.PrepareConstruction(objects, forcedViewSpace);
 
@@ -3530 +3689 @@
         mOspTree.mRoot = kdleaf;
         
-
+        // TODO matt: this is something different than pvs size.
+        const int pvsSize = mOspTree.ComputePvsSize(objects);
+        const float prop = mOspTree.mBoundingBox.GetVolume();
+
+        cout <<  "here40 pvs size: " << pvsSize << endl;
         // first osp traversal data
         OspTree::OspTraversalData oData(kdleaf,
@@ -3542 +3705 @@
 
         // compute first split candidate
-        OspTree::OspSplitCandidate *oSplitCandidate = new OspTree::OspSplitCandidate(oData);
+        OspTree::OspSplitCandidate *oSplitCandidate = 
+                new OspTree::OspSplitCandidate(oData);
     mOspTree.EvalSplitCandidate(*oSplitCandidate);
 
-        mTQueue.Push(splitCandidate);
+        mTQueue.Push(oSplitCandidate);
+}
+
+
+void HierarchyManager::PrepareConstruction(const VssRayContainer &sampleRays,
+                                                                                   const ObjectContainer &objects,
+                                                                                   AxisAlignedBox3 *forcedViewSpace,
+                                                                                   RayInfoContainer &rays)
+{
+        PrepareVsp(sampleRays, forcedViewSpace, rays);
+        PrepareOsp(objects, forcedViewSpace);
 }
 
@@ -3561 +3735 @@
 {
         RayInfoContainer *rays = new RayInfoContainer();
-
-        mVspTree.PrepareConstruction(sampleRays, forcedViewSpace);
+        PrepareVsp(sampleRays, forcedViewSpace, *rays);
 
         long startTime = GetTime();
-
-        cout << "storing rays ... ";
-
-        Intersectable::NewMail();
-
-        VssRayContainer::const_iterator rit, rit_end = sampleRays.end();
-
-        //-- store rays
-        for (rit = sampleRays.begin(); rit != rit_end; ++ rit)
-        {
-                VssRay *ray = *rit;
-
-                float minT, maxT;
-
-                static Ray hray;
-                hray.Init(*ray);
-                
-                // TODO: not very efficient to implictly cast between rays types
-                if (mVspTree.GetBoundingBox().GetRaySegment(hray, minT, maxT))
-                {
-                        float len = ray->Length();
-
-                        if (!len)
-                                len = Limits::Small;
-
-                        rays->push_back(RayInfo(ray, minT / len, maxT / len));
-                }
-        }
-
-        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-
-        const int pvsSize = mVspTree.ComputePvsSize(*rays);
-
-
-        // -- prepare view space partition
-
-        // add first candidate for view space partition
-        VspLeaf *vspleaf = new VspLeaf();
-
-        mVspTree.mRoot = vspleaf;
-        const float prop = mVspTree.mBoundingBox.GetVolume();
-
-        // first vsp traversal data
-        VspTree::VspTraversalData vData(vspleaf,
-                                                                        0,
-                                                                        rays,
-                                                                        pvsSize,        
-                                                                        prop,
-                                                                        mVspTree.mBoundingBox);
-
-
-        //-- compute first split candidate
-        VspTree::VspSplitCandidate *splitCandidate = new VspTree::VspSplitCandidate(vData);
-    mVspTree.EvalSplitCandidate(*splitCandidate);
-
-        mTQueue.Push(splitCandidate);
-
+        cout << "starting vsp contruction ... " << endl;
         int i = 0;
 
@@ -3631 +3748 @@
                         GlobalTerminationCriteriaMet(splitCandidate);
 
-                //cout << "vsp nodes: " << i ++ << endl;
+                cout << "vsp nodes: " << i ++ << endl;
 
                 // cost ratio of cost decrease / totalCost
                 const float costRatio = splitCandidate->GetPriority() / mTotalCost;
-                //Debug << "cost ratio: " << costRatio << endl;
+                //cout << "cost ratio: " << costRatio << endl;
 
                 if (costRatio < mTermMinGlobalCostRatio)
@@ -3646 +3763 @@
                         dynamic_cast<VspTree::VspSplitCandidate *>(splitCandidate);
 
+        
                 VspNode *r = mVspTree.Subdivide(mTQueue, *sc, globalTerminationCriteriaMet);
-        
+
                 DEL_PTR(splitCandidate);
         }
@@ -3654 +3772 @@
         mVspTree.mVspStats.Stop();
         
-        Debug << "object space" << endl;
+        startTime = GetTime();
+        cout << "starting osp contruction ... " << endl;
 
         //-- object space partition
-
-        mOspTree.PrepareConstruction(objects, forcedViewSpace);
-
-        // add first candidate for view space partition
-        KdLeaf *leaf = new KdLeaf(NULL, 0);
-        leaf->mObjects = objects;
-
-        mOspTree.mRoot = leaf;
-        
-
-        //-- first osp traversal data
-        OspTree::OspTraversalData oData(leaf,
-                                                                        0,
-                                                                        pvsSize,
-                                                                        prop,
-                                                                        mOspTree.mBoundingBox);
-
-                
-        mOspTree.ProcessLeafObjects(leaf, NULL);
-
-        // compute first split candidate
-        OspTree::OspSplitCandidate *oSplitCandidate = new OspTree::OspSplitCandidate(oData);
-    mOspTree.EvalSplitCandidate(*oSplitCandidate);
-
-        mTQueue.Push(oSplitCandidate);
+    PrepareOsp(objects, forcedViewSpace);
 
         i = 0;
@@ -3733 +3828 @@
         while (!FinishedConstruction())
         {
-                SplitCandidate *splitCandidate = NextSplitCandidate();
-            
+                mCurrentCandidate = NextSplitCandidate();
+           
                 const bool globalTerminationCriteriaMet = 
-                        GlobalTerminationCriteriaMet(splitCandidate);
+                        GlobalTerminationCriteriaMet(mCurrentCandidate);
 
                 cout << "view cells: " << i ++ << endl;
 
                 // cost ratio of cost decrease / totalCost
-                const float costRatio = splitCandidate->GetPriority() / mTotalCost;
+                const float costRatio = mCurrentCandidate->GetPriority() / mTotalCost;
                 //Debug << "cost ratio: " << costRatio << endl;
 
@@ -3750 +3845 @@
 
                 // we have either a object space or view space split
-                if (splitCandidate->Type() == SplitCandidate::VIEW_SPACE)
+                if (mCurrentCandidate->Type() == SplitCandidate::VIEW_SPACE)
                 {
                         VspTree::VspSplitCandidate *sc = 
-                                dynamic_cast<VspTree::VspSplitCandidate *>(splitCandidate);
+                                dynamic_cast<VspTree::VspSplitCandidate *>(mCurrentCandidate);
 
                         VspNode *r = mVspTree.Subdivide(mTQueue, *sc, globalTerminationCriteriaMet);
@@ -3760 +3855 @@
                 {                       
                         OspTree::OspSplitCandidate *sc = 
-                                dynamic_cast<OspTree::OspSplitCandidate *>(splitCandidate);
+                                dynamic_cast<OspTree::OspSplitCandidate *>(mCurrentCandidate);
 
                         KdNode *r = mOspTree.Subdivide(mTQueue, *sc, globalTerminationCriteriaMet);
                 }
 
-                DEL_PTR(splitCandidate);
+                // reevaluate affected candidates
+                RepairQueue();
+
+                DEL_PTR(mCurrentCandidate);
         }
 
@@ -3780 +3878 @@
 
 
-void HierarchyManager::RepairQueue(const vector<SplitCandidate *> &dirtyList)
+void HierarchyManager::CollectDirtyCandidates(vector<SplitCandidate *> &dirtyList)
+{       
+        // we have either a object space or view space split
+        if (mCurrentCandidate->Type() == SplitCandidate::VIEW_SPACE)
+        {
+                VspTree::VspSplitCandidate *sc = 
+                        dynamic_cast<VspTree::VspSplitCandidate *>(mCurrentCandidate);
+
+                mVspTree.CollectDirtyCandidates(sc, dirtyList);
+        }
+        else // object space split
+        {                       
+                OspTree::OspSplitCandidate *sc = 
+                        dynamic_cast<OspTree::OspSplitCandidate *>(mCurrentCandidate);
+
+                mOspTree.CollectDirtyCandidates(sc, dirtyList);
+        }
+}
+
+
+void HierarchyManager::RepairQueue()
 {
         // TODO
@@ -3799 +3917 @@
         // split candidate
 
+        // collect list of "dirty" candidates
+        vector<SplitCandidate *> dirtyList;
+        CollectDirtyCandidates(dirtyList);
+        
+        //-- reevaluate the dirty list
         vector<SplitCandidate *>::const_iterator sit, sit_end = dirtyList.end();