Changeset 1633 for GTP/trunk

Timestamp:

10/17/06 20:32:06 (18 years ago)

Author:

mattausch

Message:

worked on gradient method for vsposp

Location:

GTP/trunk/Lib/Vis/Preprocessing

Files:

• scripts/vsposp_typical.env (added)
• scripts/vsposp_typical.sh (added)
• src/BvHierarchy.cpp (modified) (8 diffs)
• src/BvHierarchy.h (modified) (3 diffs)
• src/Environment.cpp (modified) (1 diff)
• src/HierarchyManager.cpp (modified) (18 diffs)
• src/HierarchyManager.h (modified) (4 diffs)
• src/KdTree.cpp (modified) (3 diffs)
• src/KdTree.h (modified) (1 diff)
• src/OspTree.cpp (modified) (5 diffs)
• src/OspTree.h (modified) (7 diffs)
• src/Preprocessor.cpp (modified) (2 diffs)
• src/Preprocessor.vcproj (modified) (1 diff)
• src/SubdivisionCandidate.cpp (added)
• src/SubdivisionCandidate.h (modified) (4 diffs)
• src/ViewCell.cpp (modified) (1 diff)
• src/ViewCellsManager.cpp (modified) (4 diffs)
• src/ViewCellsParser.cpp (modified) (1 diff)
• src/VspTree.cpp (modified) (9 diffs)
• src/VspTree.h (modified) (5 diffs)
• src/main.cpp (modified) (1 diff)

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

@@ -509 +509 @@
 
         const float renderCostDecr = oldRenderCost - newRenderCost;
-        const int pvsEntriesIncr = EvalPvsEntriesIncr(splitCandidate);
-
+        
 #ifdef _DEBUG
         Debug << "old render cost: " << oldRenderCost << endl;
@@ -516 +515 @@
         Debug << "render cost decrease: " << renderCostDecr << endl;
 #endif
-
-        splitCandidate.SetRenderCostDecrease(renderCostDecr);
-        splitCandidate.SetPvsEntriesIncr(EvalPvsEntriesIncr(splitCandidate));
 
 #if 1
@@ -529 +525 @@
 #endif
 
+        splitCandidate.SetRenderCostDecrease(renderCostDecr);
+
+        // increase in pvs entries
+        const int pvsEntriesIncr = EvalPvsEntriesIncr(splitCandidate);
+        splitCandidate.SetPvsEntriesIncr(pvsEntriesIncr);
+
         // compute global decrease in render cost
         splitCandidate.SetPriority(priority);
+}
+
+
+float BvHierarchy::EvalPriority(const BvhSubdivisionCandidate &splitCandidate) const
+{
+        BvhLeaf *leaf = splitCandidate.mParentData.mNode;
+
+        const float oldRenderCost = EvalRenderCost(leaf->mObjects);
+
+        // compute global decrease in render cost
+        const float newRenderCost = 
+                EvalRenderCost(splitCandidate.mFrontObjects) +
+                EvalRenderCost(splitCandidate.mBackObjects);
+
+        const float renderCostDecr = oldRenderCost - newRenderCost;
+
+#ifdef _DEBUG
+        Debug << "old render cost: " << oldRenderCost << endl;
+        Debug << "new render cost: " << newRenderCost << endl;
+        Debug << "render cost decrease: " << renderCostDecr << endl;
+#endif
+
+#if 1
+        // take render cost of node into account 
+        // otherwise danger of being stuck in a local minimum!!
+        const float factor = mRenderCostDecreaseWeight;
+        const float priority = factor * renderCostDecr + (1.0f - factor) * oldRenderCost;
+#else
+        const float priority = (float)-splitCandidate.mParentData.mDepth;
+#endif
+
+        return priority;
 }
 
@@ -569 +603 @@
                 );
 
-        if (1 && terminationCriteriaMet)
+#ifdef _DEBUG
+        if (terminationCriteriaMet)
         {
                 Debug << "bvh global termination criteria met:" << endl;
@@ -575 +610 @@
                 Debug << "leaves: " << mBvhStats.Leaves() << " " << mTermMaxLeaves << endl;
         }
-
+#endif
         return terminationCriteriaMet; 
 }
@@ -1529 +1564 @@
 
 void BvHierarchy::CollectDirtyCandidates(BvhSubdivisionCandidate *sc, 
-                                                                                 vector<SubdivisionCandidate *> &dirtyList)
+                                                                                 vector<SubdivisionCandidate *> &dirtyList, 
+                                                                                 const bool onlyUnmailed)
 {
         BvhTraversalData &tData = sc->mParentData;
@@ -1535 +1571 @@
         
         ViewCellContainer viewCells;
-        CollectViewCells(node->mObjects, viewCells);
+        ViewCell::NewMail();
+        CollectViewCells(node->mObjects, viewCells, true);
+
         if (0) cout << "collected " << (int)viewCells.size() << " dirty candidates" << endl;
-
+        
         // split candidates handling 
         // these view cells  are thrown into dirty list
@@ -1544 +1582 @@
         for (vit = viewCells.begin(); vit != vit_end; ++ vit)
         {
-                VspViewCell *vc = dynamic_cast<VspViewCell *>(*vit);
+        VspViewCell *vc = dynamic_cast<VspViewCell *>(*vit);
                 VspLeaf *leaf = vc->mLeaves[0];
+        
                 SubdivisionCandidate *candidate = leaf->GetSubdivisionCandidate();
                 
-                if (candidate) // is this leaf still a split candidate?
-                {
+                // is this leaf still a split candidate?
+                if (candidate && (!onlyUnmailed || !candidate->Mailed()))
+                {
+                        candidate->Mail();
                         dirtyList.push_back(candidate);
                 }

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

@@ -403 +403 @@
                 int Type() const { return OBJECT_SPACE; }
         
-                void EvalPriority()
+                void EvalPriority(bool computeSplitplane = true)
                 {
-                        sBvHierarchy->EvalSubdivisionCandidate(*this);  
+                        if (computeSplitplane)
+                                sBvHierarchy->EvalSubdivisionCandidate(*this);  
+                        else
+                                mPriority = sBvHierarchy->EvalPriority(*this);
                 }
 
-                /*bool Apply(SplitQueue *queue, bool terminationCriteriaMet)
+                bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet)
                 {
                         BvhNode *n = sBvHierarchy->Subdivide(splitQueue, this, terminationCriteriaMet);
                         // local or global termination criteria failed
                         return !n->IsLeaf();            
-                }*/
+                }
+
+                void CollectDirtyCandidates(SubdivisionCandidateContainer &dirtyList,
+                                                                        const bool onlyUnmailed)
+                {
+                        sBvHierarchy->CollectDirtyCandidates(this, dirtyList, onlyUnmailed);
+                }
 
                 bool GlobalTerminationCriteriaMet() const
@@ -710 +719 @@
         float PrepareHeuristics(const BvhTraversalData &tData, const int axis);
         
+        /** Reevaluates the priority of this split candidate
+                @returns priority
+        */
+        float EvalPriority(const BvhSubdivisionCandidate &splitCandidate) const;
+
         ////////////////////////////////////////////////
 
@@ -725 +739 @@
         void CollectDirtyCandidates(
                 BvhSubdivisionCandidate *sc,
-                vector<SubdivisionCandidate *> &dirtyList);
+                vector<SubdivisionCandidate *> &dirtyList,
+                const bool onlyUnmailed);
 
         /** Collect view cells which see this bvh leaf.

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

@@ -2526 +2526 @@
                                         "4");
 
+        
+        RegisterOption("Hierarchy.Construction.recomputeSplitPlaneOnRepair",
+                                        optBool,
+                                        "hierarchy_construction_recompute_split_on_repair=",
+                                        "true");
+
         /////////////////////////////////////////////////////////////////
 }

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

@@ -113 +113 @@
         mSubdivisionStats.open(subdivisionStatsLog);
 
-        //mMinRenderCostDecrease = -1;
+        Environment::GetSingleton()->GetBoolValue(
+                "Hierarchy.Construction.recomputeSplitPlaneOnRepair", mRecomputeSplitPlaneOnRepair);
 
         Debug << "******** Hierachy Manager Parameters ***********" << endl;
@@ -122 +123 @@
         Debug << "repair queue: " << mRepairQueue << endl;
         Debug << "number of multilevels: " << mNumMultiLevels << endl;
+        Debug << "recompute split plane on repair: " << mRecomputeSplitPlaneOnRepair << endl;
 
         switch (mConstructionType)
@@ -259 +261 @@
                 (0
                 || (mHierarchyStats.Leaves() >= mTermMaxLeaves) 
-                || (mHierarchyStats.mGlobalCostMisses >= mTermGlobalCostMissTolerance)
+                //|| (mHierarchyStats.mGlobalCostMisses >= mTermGlobalCostMissTolerance)
                 || (candidate->GlobalTerminationCriteriaMet())
                 //|| (mHierarchyStats.mRenderCostDecrease < mMinRenderCostDecrease)
@@ -316 +318 @@
         // compute view space bounding box
         mVspTree->ComputeBoundingBox(sampleRays, forcedViewSpace);
+
+        SplitQueue objectSpaceQueue;
+        SplitQueue viewSpaceQueue;
 
         // use sah for evaluating osp tree construction 
@@ -324 +329 @@
         mSavedObjectSpaceSubdivisionType = mObjectSpaceSubdivisionType;
 
-        SplitQueue objectSpaceQueue;
-        SplitQueue viewSpaceQueue;
-
         // number of initial splits
         int maxSteps = 200;
         float renderCostDecr = 0;
+
+        SubdivisionCandidate *osc = 
+                PrepareObjectSpaceSubdivision(sampleRays, objects);
+        
+        objectSpaceQueue.Push(osc);
+
+        /////////////////////////
+        // calulcate initial object space splits
+        
+        SubdivisionCandidateContainer dirtyVspList;
+
+        // subdivide object space first
+        // for first round, use sah splits. Once view space partition
+        // has started, use render cost heuristics instead
+        const int ospSteps = 
+                RunConstruction(objectSpaceQueue, dirtyVspList, renderCostDecr, maxSteps);
+
+        cout << ospSteps << " object space partition steps taken" << endl;
+
+        SubdivisionCandidate *vsc = 
+                        PrepareViewSpaceSubdivision(sampleRays, objects);
+
+        viewSpaceQueue.Push(vsc);
+
+        // view space subdivision was constructed
+        mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
+
+        // don't terminate on max steps
+        //maxSteps = mTermMaxLeaves;
 
         // This method subdivides view space / object space 
@@ -337 +368 @@
         // and vice versa until iteration depth is reached.
 
-        while (1)
-        {
-                // subdivide object space first
-                // for first round, use sah splits. Once view space partition
-                // has started, use render cost heuristics instead
-                SubdivisionCandidate *osc = 
-                        ResetObjectSpaceSubdivision(sampleRays, objects);
-                objectSpaceQueue.Push(osc);
-
-                // process object space candidates using render queue for 
-                // objects until slope of previous subdivision is reached
-                SubdivisionCandidateContainer ospContainer;
-
-                const int ospSteps = 
-                        RunConstruction(objectSpaceQueue, ospContainer, renderCostDecr, maxSteps);
-            cout << ospSteps << " object space partition steps taken" << endl;
-
-                // use splits of one kind until rendercost slope is reached
-                renderCostDecr = mHierarchyStats.mRenderCostDecrease;
+        while (!(viewSpaceQueue.Empty() && objectSpaceQueue.Empty()))
+        {
+                // should view or object space be subdivided further?
+                if (viewSpaceQueue.Empty() ||
+                        (!objectSpaceQueue.Empty() &&
+                        (objectSpaceQueue.Top()->GetPriority() > viewSpaceQueue.Top()->GetPriority())))
+                {
+                        // use splits of one kind until rendercost slope is reached
+                        renderCostDecr = mHierarchyStats.mRenderCostDecrease;
+
+                        // dirtied view space candidates
+                        SubdivisionCandidateContainer dirtyVspList;
+
+                        // subdivide object space first
+                        // for first round, use sah splits. Once view space partition
+                        // has started, use render cost heuristics instead
+                        const int ospSteps = 
+                                RunConstruction(objectSpaceQueue, dirtyVspList, renderCostDecr, maxSteps);
+
+                        cout << ospSteps << " object space partition steps taken" << endl;
                 
-                // object space subdivision constructed
-                mObjectSpaceSubdivisionType = mSavedObjectSpaceSubdivisionType;
-
-                /// Repair split queue
-                cout << "repairing queue ... " << endl;
-                
-                vector<SubdivisionCandidate *> dirtyList;
-
-                CollectDirtyCandidates(ospContainer, dirtyList);
-                //RepairQueue(dirtyList, viewSpaceQueue);
-
-                cout << "finished repairing queue ... " << endl;
-                
-                CLEAR_CONTAINER(ospContainer);
-
-                /////////////////
-                // subdivide view space with respect to the objects
-
-                SubdivisionCandidate *vsc = 
-                        ResetViewSpaceSubdivision(sampleRays, objects);
-                viewSpaceQueue.Push(vsc);
-
-                SubdivisionCandidateContainer vspContainer;
-                // process view space candidates
-                const int vspSteps = 
-                        RunConstruction(viewSpaceQueue, vspContainer, renderCostDecr, maxSteps);
-
-                cout << vspSteps << " view space partition steps taken" << endl;
-
-                // view space subdivision constructed
-                mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
-
-                // use splits of one kind until rendercost slope is reached
-                renderCostDecr = mHierarchyStats.mRenderCostDecrease;
-
-                /// Repair split queue
-                cout << "repairing queue ... " << endl;
-                
-                CollectDirtyCandidates(vspContainer, dirtyList);
-                //RepairQueue(dirtyList, objectSpaceQueue);
-
-                cout << "finished repairing queue ... " << endl;
-
-                CLEAR_CONTAINER(vspContainer);
-        }
-        
+                        // object space subdivision constructed
+                        mObjectSpaceSubdivisionType = mSavedObjectSpaceSubdivisionType;
+
+                        /// Repair split queue
+                        cout << "repairing queue ... " << endl;
+                        RepairQueue(dirtyVspList, viewSpaceQueue, true);
+                        cout << "repaired " << dirtyVspList.size() << " candidates" << endl;
+                }
+                else
+                {
+                        // use splits of one kind until rendercost slope is reached
+                        renderCostDecr = mHierarchyStats.mRenderCostDecrease;
+
+                        /////////////////
+                        // subdivide view space with respect to the objects
+
+                        SubdivisionCandidateContainer dirtyOspList;
+
+                        // process view space candidates
+                        const int vspSteps = 
+                                RunConstruction(viewSpaceQueue, dirtyOspList, renderCostDecr, maxSteps);
+
+                        cout << vspSteps << " view space partition steps taken" << endl;
+
+                        // view space subdivision constructed
+                        mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
+
+                        /// Repair split queue
+                        cout << "repairing queue ... " << endl;
+                        RepairQueue(dirtyOspList, objectSpaceQueue, true);
+                        cout << "repaired " << dirtyOspList.size() << " candidates" << endl;
+                }
+        }
+
         cout << "\nfinished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
 
@@ -432 +452 @@
         mVspTree->ComputeBoundingBox(sampleRays, forcedViewSpace);
 
-        // use objects for evaluating vsp tree construction in the first levels
-        // of the subdivision
+        // use objects for evaluating vsp tree construction in the 
+        // first levels of the subdivision
         mSavedObjectSpaceSubdivisionType = mObjectSpaceSubdivisionType;
         mObjectSpaceSubdivisionType = NO_OBJ_SUBDIV;
@@ -557 +577 @@
                                                                                                  const bool repairQueue)
 {
-        // test if global termination criteria were met before this split
         const bool terminationCriteriaMet = GlobalTerminationCriteriaMet(sc);
-        const bool vspSplit = (sc->Type() == SubdivisionCandidate::VIEW_SPACE);
-
-        bool success = false;
-
-        switch (sc->Type())
-        {
-        case SubdivisionCandidate::VIEW_SPACE:
-                {
-                        VspNode *n = mVspTree->Subdivide(splitQueue, sc, terminationCriteriaMet);
-
-                        // check if terminated
-                        success = !n->IsLeaf();
-                }
-                break;
-        case SubdivisionCandidate::OBJECT_SPACE:
-                {
-                        if (mObjectSpaceSubdivisionType == KD_BASED_OBJ_SUBDIV)
-                        {
-                                KdNode *n = mOspTree->Subdivide(splitQueue, sc, terminationCriteriaMet);
-
-                                // local or global termination criteria failed
-                                success = !n->IsLeaf();
-                        }
-                        else if (mObjectSpaceSubdivisionType == BV_BASED_OBJ_SUBDIV)
-                        {
-                                BvhNode *n = mBvHierarchy->Subdivide(splitQueue, sc, terminationCriteriaMet);
-
-                                // local or global termination criteria failed
-                                success = !n->IsLeaf();                                 
-                        }
-                }
-                break;
-        default:
-                cerr << "unknown subdivision type" << endl;
-                break;
-        }
+
+        const bool success = sc->Apply(splitQueue, terminationCriteriaMet);
 
         if (!success) // split was not taken
@@ -635 +620 @@
                 // this would be object space splits and other way round
                 vector<SubdivisionCandidate *> dirtyList;
-                CollectDirtyCandidates(sc, dirtyList);
-
-                RepairQueue(dirtyList, splitQueue);
+                sc->CollectDirtyCandidates(dirtyList, false);
+
+                RepairQueue(dirtyList, splitQueue, mRecomputeSplitPlaneOnRepair);
         }
 
@@ -766 +751 @@
                 ////////
                 //-- subdivide leaf node of either type
-
                 ApplySubdivisionCandidate(sc, mTQueue, repairQueue);
-
                 DEL_PTR(sc);
         }
@@ -775 +758 @@
 
 int HierarchyManager::RunConstruction(SplitQueue &splitQueue,
-                                                                          SubdivisionCandidateContainer &chosenCandidates,
+                                                                          SubdivisionCandidateContainer &dirtyCandidates,
                                                                           const float minRenderCostDecr,
                                                                           const int maxSteps)
 {
         int steps = 0;
+        SubdivisionCandidate::NewMail();
 
         // main loop
-        while (!splitQueue.Empty() && ((steps ++) < maxSteps))
+        while (!splitQueue.Empty() && (steps < maxSteps))
         {
                 SubdivisionCandidate *sc = NextSubdivisionCandidate(splitQueue); 
                 
                 // minimum slope reached
-                if (sc->GetRenderCostDecrease() < minRenderCostDecr)
-                        break;
+                //if (sc->GetRenderCostDecrease() < minRenderCostDecr)  break;
 
                 ////////
@@ -794 +777 @@
 
                 const bool repairQueue = false;
-                bool success = ApplySubdivisionCandidate(sc, splitQueue, repairQueue);
+                const bool success = ApplySubdivisionCandidate(sc, splitQueue, repairQueue);
 
                 if (success)
                 {
-                        chosenCandidates.push_back(sc);
+                        sc->CollectDirtyCandidates(dirtyCandidates, true);
+                        //cout << "collected " << dirtyCandidates.size() << "dirty candidates" << endl;
+                        ++ steps;
                 }
         }
@@ -826 +811 @@
         
                         firstCandidate = mBvHierarchy->Reset(sampleRays, objects);
-                        cout << "here4" << endl;
+                
                         mHierarchyStats.mTotalCost = mBvHierarchy->mTotalCost;
 
@@ -835 +820 @@
                         // evaluate stats before first subdivision
                         EvalSubdivisionStats();
-                        cout << "here5" << endl;
                 }
                 break;
@@ -845 +829 @@
                 break;
         }
-cout << "here6" << endl;
+
         return firstCandidate;
 }
@@ -990 +974 @@
 
 
-void HierarchyManager::CollectObjectSpaceDirtyList(SubdivisionCandidate *sc,
-                                                                                                   SubdivisionCandidateContainer &dirtyList)
-{
-        switch (mObjectSpaceSubdivisionType)
-        {
-        case KD_BASED_OBJ_SUBDIV:
-                {
-                        OspTree::OspSubdivisionCandidate *ospSc = 
-                                dynamic_cast<OspTree::OspSubdivisionCandidate *>(sc);
-
-                        mOspTree->CollectDirtyCandidates(ospSc, dirtyList);
-                        break;
-                }
-        case BV_BASED_OBJ_SUBDIV:
-                {
-                        BvHierarchy::BvhSubdivisionCandidate *bvhSc = 
-                                dynamic_cast<BvHierarchy::BvhSubdivisionCandidate *>(sc);
-
-                        mBvHierarchy->CollectDirtyCandidates(bvhSc, dirtyList);
-                        break;
-                }
-        default:
-                break;
-        }
-}
-
-
-void HierarchyManager::CollectViewSpaceDirtyList(SubdivisionCandidate *sc, 
-                                                                                                 SubdivisionCandidateContainer &dirtyList)
-{
-        VspTree::VspSubdivisionCandidate *vspSc = 
-                dynamic_cast<VspTree::VspSubdivisionCandidate *>(sc);
-
-        mVspTree->CollectDirtyCandidates(vspSc, dirtyList);
-}
-
-
-void HierarchyManager::CollectDirtyCandidates(SubdivisionCandidate *sc, 
-                                                                                          SubdivisionCandidateContainer &dirtyList)
-{
-        // we have either a object space or view space split
-        if (sc->Type() == SubdivisionCandidate::VIEW_SPACE)
-        {
-                CollectViewSpaceDirtyList(sc, dirtyList);
-        }
-        else // object space split
-        {
-                CollectObjectSpaceDirtyList(sc, dirtyList);
-        }
-}
-
-
 void HierarchyManager::CollectDirtyCandidates(const SubdivisionCandidateContainer &chosenCandidates, 
                                                                                           SubdivisionCandidateContainer &dirtyList)
 {
         SubdivisionCandidateContainer::const_iterator sit, sit_end = chosenCandidates.end();
+        SubdivisionCandidate::NewMail();
 
         for (sit = chosenCandidates.begin(); sit != sit_end; ++ sit)
         {
-                // we have either a object space or view space split
-                if ((*sit)->Type() == SubdivisionCandidate::VIEW_SPACE)
-                {
-                        CollectViewSpaceDirtyList(*sit, dirtyList);
-                }
-                else // object space split
-                {
-                        CollectObjectSpaceDirtyList(*sit, dirtyList);
-                }
-        }
-}
-
-
-void HierarchyManager::RepairQueue(const vector<SubdivisionCandidate *> &dirtyList, 
-                                                                   SplitQueue &splitQueue)
+                (*sit)->CollectDirtyCandidates(dirtyList, true);
+        }
+}
+
+
+void HierarchyManager::RepairQueue(const SubdivisionCandidateContainer &dirtyList, 
+                                                                   SplitQueue &splitQueue,
+                                                                   const bool recomputeSplitPlaneOnRepair)
 {
         // for each update of the view space partition:
@@ -1097 +1023 @@
                 
                 splitQueue.Erase(sc); // erase from queue
-                sc->EvalPriority(); // reevaluate
+                sc->EvalPriority(recomputeSplitPlaneOnRepair); // reevaluate
                 
 #ifdef _DEBUG
@@ -1113 +1039 @@
         mHierarchyStats.mRepairTime += timeDiff;
 
-        if (1) cout << "repaired in " << timeDiff * 1e-3f << " secs" << endl;
+        if (0) cout << "repaired in " << timeDiff * 1e-3f << " secs" << endl;
 }
 

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

@@ -106 +106 @@
 
 
-typedef FlexibleHeap<SubdivisionCandidate *> SplitQueue;
-
 /** This class implements a structure holding two different hierarchies,
         one for object space partitioning and one for view space partitioning.
@@ -290 +288 @@
                 list of entries is given in the dirty list.
         */
-        void RepairQueue(const vector<SubdivisionCandidate *> &dirtyList, SplitQueue &splitQueue);
+        void RepairQueue(const SubdivisionCandidateContainer &dirtyList, 
+                                         SplitQueue &splitQueue,
+                                         const bool recomputeSplitPlaneOnRepair);
 
         /** Collect subdivision candidates which were affected by the splits from the
@@ -297 +297 @@
         void CollectDirtyCandidates(const SubdivisionCandidateContainer &chosenCandidates, 
                                                                 SubdivisionCandidateContainer &dirtyList);
-
-        /** Collect the list of dirty candidates after the current 
-                subdivision candidate split.
-        */
-        void CollectDirtyCandidates(SubdivisionCandidate *sc,
-                                                                vector<SubdivisionCandidate *> &dirtyList);
 
         /** Evaluate subdivision stats for log.
@@ -497 +491 @@
         /// number of iteration steps for multilevel approach   
         int mNumMultiLevels;
+        /** if split plane should be recomputed for the repair.
+                Otherwise only the priority is recomputed, the
+                split plane itself stays the same
+        */
+        bool mRecomputeSplitPlaneOnRepair;
 };
 

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

@@ -1200 +1200 @@
 
         MeshInstance dummyInst(NULL);
-        //Debug << "objects size: " << size << endl;
-
+        
         // read object ids
+        // note: could also do this geometrically
         for (int i = 0; i < size; ++ i)
         {       
@@ -1331 +1331 @@
         ///////////////////////////
         //-- compute bounding box of object space
+
     for (oit = objects.begin(); oit != oit_end; ++ oit)
         {
@@ -1433 +1434 @@
 
 
-}
+void KdTree::InsertObjects(KdNode *node, const ObjectContainer &objects)
+{/*
+        stack<KdObjectsTraversalData> tStack;
+
+        while (!tStack.empty())
+        {
+                KdObjectsTraversalData tData = tStack.top();
+        tStack.pop();
+
+                KdNode *node = tData.node;
+                
+                if (node->IsLeaf())
+                {
+                        KdLeaf *leaf = dynamic_cast<KdLeaf *>(node);
+
+                        ObjectContainer::const_iterator oit, oit_end = tData.objects->end();
+
+                        for (oit = tData.objects->begin(); oit != oit_end; ++ oit)
+                        {
+                                leaf->mObjects.push_back(*oit);
+                        }
+                }
+                else // interior
+                {
+                        KdObjectsTraversalData frontData, backData;
+                        KdInterior *interior = dynamic_cast<KdInterior *>(node);
+
+                        frontData.objects = new ObjectContainer();
+                        backData.objects = new ObjectContainer();
+
+                        ObjectContainer::const_iterator oit, oit_end = tData.objects->end();
+                        
+                    for (oit = tData.objects->begin(); oit != oit_end; ++ oit) 
+                        {
+                                Intersectable *object = *oit;
+                
+                                // determine the side of this ray with respect to the plane
+                                const AxisAlignedBox3 box = object->GetBox();
+
+                                if (box.Max(interior->mAxis) >= interior->mPosition)
+                                {
+                                        frontData.objects->push_back(object);
+                                }
+
+                                if (box.Min(interior->mAxis) < interior->mPosition)
+                                {
+                                        backData.objects->push_back(object);
+                                }
+                        }
+
+                        tStack.push(backData);
+                        tStack.push(frontData);
+                }
+
+                DEL_PTR(tData.objects);
+        }*/
+}
+
+}

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

@@ -575 +575 @@
         KdInterior *ImportBinInterior(IN_STREAM  &stream, KdInterior *parent);
         KdNode *LoadNextNode(IN_STREAM  &stream, KdInterior *parent, const ObjectContainer &objects);
+        
+        /** Adds this objects to the kd leaf objects.
+                @warning: Can corrupt the tree
+        */
+        void InsertObjects(KdNode *node, const ObjectContainer &objects);
 
   int mTermMaxNodes;

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

@@ -1547 +1547 @@
 
 void OspTree::CollectDirtyCandidates(OspSubdivisionCandidate *sc, 
-                                                                         vector<SubdivisionCandidate *> &dirtyList)
+                                                                         vector<SubdivisionCandidate *> &dirtyList,
+                                                                         const bool onlyUnmailed)
 {
         OspTraversalData &tData = sc->mParentData;
@@ -1578 +1579 @@
         }
 
-
-        // split candidates holding this view cells 
-        // are thrown into dirty list
+        // andidates holding this view cells are thrown into dirty list
         ViewCellContainer::const_iterator vit, vit_end = viewCells.end();
 
@@ -1588 +1587 @@
 
                 VspLeaf *leaf = vc->mLeaves[0];
-                dirtyList.push_back(leaf->GetSubdivisionCandidate());
+
+                SubdivisionCandidate *dsc = leaf->GetSubdivisionCandidate();
+                if (dsc && (!onlyUnmailed || !dsc->Mailed()))
+                {
+                        dsc->Mail();
+                        dirtyList.push_back(dsc);
+                }
         }
 }
@@ -1968 +1973 @@
                                                                          ViewCell *vc, 
                                                                          float &contribution,
-                                                                         bool onlyMailed) const
+                                                                         bool onlyUnmailed) const
 {       
         contribution = 0; // todo
@@ -1977 +1982 @@
                 vdata = obj->mViewCellPvs.AddSample2(vc, 1);
         }
-        else if (!onlyMailed || !vdata->Mailed())
+        else if (!onlyUnmailed || !vdata->Mailed())
         {
                 obj->mViewCellPvs.AddSample(vc, 1);

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

@@ -12 +12 @@
 #include "SubdivisionCandidate.h"
 #include "IntersectableWrapper.h"
+#include "KdTree.h"
 
 
@@ -39 +40 @@
 class SubdivisionCandidate;
 class HierarchyManager;
-
+class KdNode;
 
 
@@ -136 +137 @@
 
 
-
-
-/** View Space Partitioning tree.
+/** Object Space Partitioning Kd tree.
 */
 class OspTree 
@@ -251 +250 @@
                 int Type() const { return OBJECT_SPACE; }
         
-                void EvalPriority()
+                void EvalPriority(bool computeSplitplane = true)
                 {
-                        sOspTree->EvalSubdivisionCandidate(*this);      
+                        if (computeSplitplane)
+                                sOspTree->EvalSubdivisionCandidate(*this);      
+                        // else TODO
                 }
 
@@ -261 +262 @@
                 }
 
+                bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet)
+                {
+                        KdNode *n = sOspTree->Subdivide(splitQueue ,this,  terminationCriteriaMet);
+
+                        // local or global termination criteria failed
+                        return !n->IsLeaf();            
+                }
+
+                void CollectDirtyCandidates(SubdivisionCandidateContainer &dirtyList,
+                                                                        const bool onlyUnmailed)
+                {
+                        sOspTree->CollectDirtyCandidates(this, dirtyList, onlyUnmailed);
+                }
 
                 OspSubdivisionCandidate(const AxisAlignedPlane &plane, const OspTraversalData &tData): 
@@ -643 +657 @@
 
         void CollectDirtyCandidates(OspSubdivisionCandidate *sc,
-                vector<SubdivisionCandidate *> &dirtyList);
+                                                                vector<SubdivisionCandidate *> &dirtyList,
+                                                                const bool onlyUnmailed);
 
         /** Collect view cells which see this kd leaf.
@@ -703 +718 @@
                 ViewCell *vc, 
                 float &contribution,
-                bool onlyMailed) const;
+                bool onlyUnmailed) const;
 
         int ClassifyRays(

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

@@ -617 +617 @@
 {
         mKdTree = new KdTree();
+
         return mKdTree->LoadBinTree(filename.c_str(), mObjects);
 }
@@ -820 +821 @@
 bool Preprocessor::InitRayCast(const string externKdTree, const string internKdTree)
 {
+        // always try to load the kd tree
         bool loadKdTree = true;
         //Environment::GetSingleton()->GetBoolValue("Preprocessor.loadKdTree", loadKdTree);
-        
-        
+                
         if (!loadKdTree)
-        {       /////////
-                //-- build new kd tree from scene geometry
-
+        {       
+                // build new kd tree from scene geometry
                 BuildKdTree();
-                KdTreeStatistics(cout);
         }
         else
         {
-                long startTime = GetTime();
                 cout << "loading kd tree file " << internKdTree << " ... ";
 
                 if (!LoadKdTree(internKdTree))
                 {
-                        cout << "error loading kd tree with filename " << internKdTree << ", rebuilding it instead ..." << endl;
-
+                        cout << "error loading kd tree with filename " << internKdTree << ", rebuilding it instead ... " << endl;
                         BuildKdTree();
-                        KdTreeStatistics(cout);
-                }
-
-                cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-
-                if (0)
-                {
-                        Exporter *exporter = Exporter::GetExporter("dummykd.x3d");
+                }
+
+                // export kd tree?
+                const long startTime = GetTime();
+                cout << "exporting kd tree ... ";
+
+                if (!ExportKdTree(internKdTree))
+                {
+                        cout << " error exporting kd tree with filename " << internKdTree << endl;
+                }
+                else
+                {
+                        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+                }
+        }
+        
+        KdTreeStatistics(cout);
+        cout << mKdTree->GetBox() << endl;
+
+        if (0)
+        {
+                Exporter *exporter = Exporter::GetExporter("dummykd.x3d");
                         
-                        if (exporter)
-                        {
-                                exporter->ExportKdTree(*mKdTree, true);
-                                delete exporter;
-                        }
-                }
-
-                // export kd tree?
-                startTime = GetTime();
-                cout << "exporting kd tree ... ";
-
-                if (!ExportKdTree(internKdTree))
-                {
-                        cout << " error exporting kd tree with filename " << internKdTree << endl;
-                }
-                else
-                {
-                        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-                }
-        }
+                if (exporter)
+                {
+                        exporter->ExportKdTree(*mKdTree, true);
+                        delete exporter;
+                }
+
+                /*ofstream objstr("objects.txt");
+
+                vector<KdLeaf *> leaves;
+                mKdTree->CollectLeaves(leaves);
+
+                vector<KdLeaf *>::const_iterator lit, lit_end = leaves.end();
+                for (lit = leaves.begin(); lit != lit_end; ++ lit)
+                {
+                        objstr << "objects: " << (*lit)->mObjects.size() << " bb " << mKdTree->GetBox(*lit) << endl;
+                }*/
+        }
+
 
         int rayCastMethod;

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

@@ -647 +647 @@
                         </File>
                         <File
+                                RelativePath=".\SubdivisionCandidate.cpp">
+                        </File>
+                        <File
                                 RelativePath=".\SubdivisionCandidate.h">
                         </File>

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

@@ -8 +8 @@
 
 namespace GtpVisibilityPreprocessor {
+
+class SubdivisionCandidate;
+
+typedef vector<SubdivisionCandidate *> SubdivisionCandidateContainer;
+typedef FlexibleHeap<SubdivisionCandidate *> SplitQueue;
 
 /** Candidate for a view space / object space split.
@@ -20 +25 @@
 
         virtual ~SubdivisionCandidate() {};
-        virtual void EvalPriority() = 0;
+        virtual void EvalPriority(bool computeSplitplane = true) = 0;
         virtual int Type() const = 0;
-        //virtual bool Apply() = 0;
+        virtual bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet) = 0;
         virtual bool GlobalTerminationCriteriaMet() const = 0;
+
+        virtual void CollectDirtyCandidates(SubdivisionCandidateContainer &dirtyList,
+                                                                                const bool onlyUnmailed) = 0;
 
         /** Set render cost decrease achieved through this split.
@@ -70 +78 @@
         }
 
+        //////////
+        //-- mailing stuff
+
+        static void NewMail(const int reserve = 1) 
+        {
+                sMailId += sReservedMailboxes;
+                sReservedMailboxes = reserve;
+        }
+
+        void Mail() { mMailbox = sMailId; }
+        bool Mailed() const { return mMailbox == sMailId; }
+
+        void Mail(const int mailbox) { mMailbox = sMailId + mailbox; }
+        bool Mailed(const int mailbox) const { return mMailbox == sMailId + mailbox; }
+
+        int IncMail() { return ++ mMailbox - sMailId; }
+
+
+        // last mail id -> warning not thread safe!
+        // both mailId and mailbox should be unique for each thread!!!
+        static int sMailId;
+        static int sReservedMailboxes;
+
 protected:
 
@@ -80 +111 @@
         /// the decrease of the number of pvs entries
         int mPvsEntriesIncr;
+
+        int mMailbox;
 };
 
-typedef FlexibleHeap<SubdivisionCandidate *> SplitQueue;
-typedef vector<SubdivisionCandidate *> SubdivisionCandidateContainer;
 
 }
 
-// FLEXIBLEHEAP_H
+// SUBDIVISIONCANDIDATE_H
 #endif

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

@@ -34 +34 @@
                                            myless<vector<ViewCell *>::value_type> > TraversalQueue;
 
-int ViewCell::sMailId = 1;//2147483647;
+int ViewCell::sMailId = 10000;//2147483647;
 int ViewCell::sReservedMailboxes = 1;
 

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

@@ -264 +264 @@
 {
         SimpleRayContainer simpleRays;
-        const long startTime = GetTime();
+        long startTime = GetTime();
 
         mPreprocessor->GenerateRays(samplesPerPass, sampleType, simpleRays);
-        Debug << "generated " << samplesPerPass << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-
+        cout << "generated " << samplesPerPass << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+
+        startTime = GetTime();
         // shoot simple ray and add it to importance samples
         mPreprocessor->CastRays(simpleRays, passSamples, true);
-        Debug << "cast " <<  samplesPerPass << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+        cout << "cast " <<  samplesPerPass << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
 
         return (int)passSamples.size();
@@ -323 +324 @@
         
         long startTime = GetTime();
-        cout << "view cell construction: casting " << mInitialSamples << " initial samples ... ";
+        cout << "view cell construction: casting " << mInitialSamples << " initial samples ... " << endl;
 
         // cast initial samples
@@ -482 +483 @@
         if (mShowVisualization)
         {
-                VssRayContainer visualizationSamples;
-
-                ////////
+                ///////////////
                 //-- visualization rays, e.g., to show some samples in the scene
-                CastPassSamples(mVisualizationSamples,
-                                            SamplingStrategy::DIRECTION_BASED_DISTRIBUTION, 
-                                                visualizationSamples);
+                
+                VssRayContainer visSamples;
+                int numSamples = CastPassSamples(mVisualizationSamples,
+                                                                                 mSamplingType, 
+                                                                                 visSamples);
 
                 if (SAMPLE_AFTER_SUBDIVISION)
-                        ComputeSampleContributions(visualizationSamples, true, storeViewCells);
+                        ComputeSampleContributions(visSamples, true, storeViewCells);
 
                 // various visualizations
-                Visualize(preprocessor->mObjects, visualizationSamples);
-
-                disposeRays(visualizationSamples, outRays);
+                Visualize(preprocessor->mObjects, visSamples);
+
+                disposeRays(visSamples, outRays);
         }
 
@@ -5128 +5129 @@
         GetRaySets(sampleRays, mVisualizationSamples, visRays);
 
-        if (1) 
-        {       
-                ////////////
-                //-- export final view cells
-
+        ////////////
+        //-- export final view cells
+
+        Exporter *exporter = Exporter::GetExporter("final_view_cells.wrl");
+
+        if (exporter)
+        {
                 // hack color code (show pvs size)
                 const int savedColorCode = mColorCode;
                 mColorCode = 0;
-        
-                Exporter *exporter = Exporter::GetExporter("final_view_cells.wrl");
-                
-                if (exporter)
-                {
-                        const long starttime = GetTime();
-                        cout << "exporting final view cells (after initial construction + post process) ... ";
-
-                        // matt: hack for clamping scene
-                        AxisAlignedBox3 bbox = mViewSpaceBox;
-                        bbox.Scale(Vector3(0.5, 1, 0.5));
-                        if (CLAMP_TO_BOX)
-                        {       
-                                exporter->SetWireframe(); 
-                                exporter->ExportBox(bbox);
-                                exporter->SetFilled(); 
-                        }
-                                
-                        if (0 && mExportGeometry)
-                        {
-                                exporter->ExportGeometry(objects, true, CLAMP_TO_BOX ? &bbox : NULL);
-                        }
-                        
-                        if (0 && mExportRays)
-                        {       
-                                exporter->ExportRays(visRays, RgbColor(0, 1, 0));
-                        }
-                
-                        mHierarchyManager->ExportObjectSpaceHierarchy(exporter, objects, CLAMP_TO_BOX ? &bbox : NULL, false);
-                        ExportViewCellsForViz(exporter, CLAMP_TO_BOX ? &bbox : NULL, GetClipPlane());
-
-                        delete exporter;
-                        cout << "finished in " << TimeDiff(starttime, GetTime()) * 1e-3f << " secs" << endl;
-                }
-
+
+                const long starttime = GetTime();
+                cout << "exporting final view cells (after initial construction + post process) ... ";
+
+                // matt: hack for clamping scene
+                AxisAlignedBox3 bbox = mViewSpaceBox;
+                bbox.Scale(Vector3(0.5, 1, 0.5));
+                if (CLAMP_TO_BOX)
+                {       
+                        exporter->SetWireframe(); 
+                        exporter->ExportBox(bbox);
+                        exporter->SetFilled(); 
+                }
+
+                if (0 && mExportGeometry)
+                {
+                        exporter->ExportGeometry(objects, true, CLAMP_TO_BOX ? &bbox : NULL);
+                }
+
+                if (1 && mExportRays)
+                {       
+                        exporter->ExportRays(visRays, RgbColor(0, 1, 0));
+                }
+
+                mHierarchyManager->ExportObjectSpaceHierarchy(exporter, objects, CLAMP_TO_BOX ? &bbox : NULL, false);
+                ExportViewCellsForViz(exporter, CLAMP_TO_BOX ? &bbox : NULL, GetClipPlane());
+
+                delete exporter;
+                cout << "finished in " << TimeDiff(starttime, GetTime()) * 1e-3f << " secs" << endl;
                 mColorCode = savedColorCode;
         }
 
-        if (1)
-        {
-                // export final object partition
-                Exporter *exporter = Exporter::GetExporter("final_object_partition.wrl");
-
-                if (exporter)
-                {
-                        const long starttime = GetTime();
-                        
-                        // matt: hack for making visualization smaller in size
-                        AxisAlignedBox3 bbox = mHierarchyManager->GetObjectSpaceBox();
-                        bbox.Scale(Vector3(0.5, 1, 0.5));
-
-                        cout << "exporting object space hierarchy ... ";
-                        mHierarchyManager->ExportObjectSpaceHierarchy(exporter, objects, CLAMP_TO_BOX ? &bbox : NULL);
-                
-                        delete exporter;
-                        cout << "finished in " << TimeDiff(starttime, GetTime()) * 1e-3f << " secs" << endl;
-                }
-        }
-        
+        // export final object partition
+        exporter = Exporter::GetExporter("final_object_partition.wrl");
+
+        if (exporter)
+        {
+                const long starttime = GetTime();
+
+                // matt: hack for making visualization smaller in size
+                AxisAlignedBox3 bbox = mHierarchyManager->GetObjectSpaceBox();
+                bbox.Scale(Vector3(0.5, 1, 0.5));
+
+                cout << "exporting object space hierarchy ... ";
+                mHierarchyManager->ExportObjectSpaceHierarchy(exporter, objects, CLAMP_TO_BOX ? &bbox : NULL);
+
+                delete exporter;
+                cout << "finished in " << TimeDiff(starttime, GetTime()) * 1e-3f << " secs" << endl;
+        }
+
+        
+        //  visualization of the view cells
+        if (0) ExportMergedViewCells(objects);
+
         // export some view cell
         int leafOut;

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

@@ -161 +161 @@
         {
                 // for a spatial subdivision, it is not necessary to store
-                // the objects with the leaves, they can be classified now
+                // the objects with the leaves, they can be classified
+                // geometrically
                 mHierarchyManager->mOspTree->InsertObjects(
                         mHierarchyManager->mOspTree->mRoot, *mObjects);

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

@@ -694 +694 @@
         if (!LocalTerminationCriteriaMet(tData) && !globalCriteriaMet)
         {       
+                ///////////
                 //-- continue subdivision
+
                 VspTraversalData tFrontData;
                 VspTraversalData tBackData;
@@ -714 +716 @@
                 if (1) EvalSubdivisionStats(*sc);
                 
+                /////////////
                 //-- evaluate new split candidates for global greedy cost heuristics
 
@@ -728 +731 @@
                 tQueue.Push(frontCandidate);
                 tQueue.Push(backCandidate);
-                
-                // delete old leaf node
-                //DEL_PTR(tData.mNode);
+
+                // note: leaf is not destroyed because it is needed to collect 
+                // dirty candidates in hierarchy manager
         }
 
@@ -825 +828 @@
         
         splitCandidate.SetPriority(priority);
+}
+
+
+float VspTree::EvalPriority(const VspSubdivisionCandidate &splitCandidate) const
+{
+        // compute global decrease in render cost
+        float oldRenderCost;
+        const float renderCostDecr = EvalRenderCostDecrease(splitCandidate.mSplitPlane, 
+                                                                                                                splitCandidate.mParentData,
+                                                                                                                oldRenderCost);
+    
+#if 0
+        const float priority = (float)-splitCandidate.mParentData.mDepth;
+#else
+        // take render cost of node into account 
+        // otherwise danger of being stuck in a local minimum!!
+        const float factor = mRenderCostDecreaseWeight;
+        const float priority = factor * renderCostDecr + (1.0f - factor) * oldRenderCost;
+#endif
+        
+        return priority;
 }
 
@@ -2872 +2896 @@
 void VspTree::CollectDirtyCandidate(const VssRay &ray, 
                                                                         const bool isTermination,
-                                                                        vector<SubdivisionCandidate *> &dirtyList) const
+                                                                        vector<SubdivisionCandidate *> &dirtyList,
+                                                                        const bool onlyUnmailed) const
 {
 
@@ -2882 +2907 @@
         
         if (!obj) return;
-
+        
+        SubdivisionCandidate *candidate = NULL;
+                
         switch (mHierarchyManager->GetObjectSpaceSubdivisionType())
         {
@@ -2892 +2919 @@
                         {
                                 leaf->Mail();
-                                dirtyList.push_back(leaf->mSubdivisionCandidate);
+                                candidate = leaf->mSubdivisionCandidate;
                         }
                         break;
@@ -2903 +2930 @@
                         {
                                 leaf->Mail();
-                                 // a candidate still attached to this node
-                                if (leaf->GetSubdivisionCandidate())
-                                {
-                                        dirtyList.push_back(leaf->GetSubdivisionCandidate());
-                                }
+                                candidate = leaf->GetSubdivisionCandidate();
                         }
                         break;
                 }
         default:
+                cerr << "not implemented yet" << endl;
+                candidate = NULL;
                 break;
         }
+
+        // is this leaf still a split candidate?
+        if (candidate && (!onlyUnmailed || !candidate->Mailed()))
+        {
+                candidate->Mail();
+                dirtyList.push_back(candidate);
+        }
 }
 
 
 void VspTree::CollectDirtyCandidates(VspSubdivisionCandidate *sc, 
-                                                                         vector<SubdivisionCandidate *> &dirtyList)
+                                                                         vector<SubdivisionCandidate *> &dirtyList,
+                                                                         const bool onlyUnmailed)
 {
         VspTraversalData &tData = sc->mParentData;
@@ -2933 +2966 @@
                 VssRay *ray = (*rit).mRay;
                 
-                CollectDirtyCandidate(*ray, true, dirtyList);
-                CollectDirtyCandidate(*ray, false, dirtyList);
+                CollectDirtyCandidate(*ray, true, dirtyList, onlyUnmailed);
+        CollectDirtyCandidate(*ray, false, dirtyList, onlyUnmailed);
         }
 }

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

@@ -457 +457 @@
                 int Type() const { return VIEW_SPACE; }
 
-                void EvalPriority()
+                void EvalPriority(bool computeSplitplane = true)
                 {
-                        sVspTree->EvalSubdivisionCandidate(*this);      
+                        if (computeSplitplane)
+                                sVspTree->EvalSubdivisionCandidate(*this);      
+                        else
+                                mPriority = sVspTree->EvalPriority(*this);
                 }
 
@@ -467 +470 @@
                 }
 
-                VspSubdivisionCandidate(
-                        const AxisAlignedPlane &plane, 
-                        const VspTraversalData &tData): 
+                bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet)
+                {
+                        VspNode *n = sVspTree->Subdivide(splitQueue, this, terminationCriteriaMet);
+                        
+                        // local or global termination criteria failed
+                        return !n->IsLeaf();            
+                }
+
+                void CollectDirtyCandidates(SubdivisionCandidateContainer &dirtyList,
+                                                                        const bool onlyUnmailed)
+                {
+                        sVspTree->CollectDirtyCandidates(this, dirtyList, onlyUnmailed);
+                }
+
+        VspSubdivisionCandidate(const AxisAlignedPlane &plane, const VspTraversalData &tData): 
                 mSplitPlane(plane), mParentData(tData)
                 {}
@@ -833 +848 @@
         int PrepareHeuristics(KdLeaf *leaf);
 
+        /** Reevaluates the priority of this split candidate
+                @returns priority
+        */
+        float EvalPriority(const VspSubdivisionCandidate &splitCandidate) const;
+
         /////////////////////////////////////////////////////////////////////////////
 
@@ -939 +959 @@
         */
         void ProcessViewCellObjects(ViewCell *parent, 
-                ViewCell *front, 
-                ViewCell *back) const;
+                                                                ViewCell *front, 
+                                                                ViewCell *back) const;
 
         void CreateViewCell(VspTraversalData &tData, const bool updatePvs);
@@ -947 +967 @@
                 and must be reevaluated.
         */
-        void CollectDirtyCandidates(VspSubdivisionCandidate *sc, vector<SubdivisionCandidate *> &dirtyList);
-
-        void CollectDirtyCandidate(
-                const VssRay &ray, 
-                const bool isTermination,
-                vector<SubdivisionCandidate *> &dirtyList) const;
+        void CollectDirtyCandidates(VspSubdivisionCandidate *sc, 
+                                                                vector<SubdivisionCandidate *> &dirtyList,
+                                                                const bool onlyUnmailed);
+
+        void CollectDirtyCandidate(const VssRay &ray, 
+                                                           const bool isTermination,
+                                                           vector<SubdivisionCandidate *> &dirtyList,
+                                                           const bool onlyUnmailed) const;
 
         /** Rays will be clipped to the bounding box.

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

@@ -76 +76 @@
 {
         //Environment::GetSingleton()->GetStringValue("Preprocessor.kdTreeFilename", internKdTree);
-        
+        string suffix;
+
+        if (preprocessor->mLoadMeshes)
+        {
+                suffix = ".kdm";        
+        }
+        else
+        {
+                suffix = ".kdt";
+        }
+
         // hack! should take any extension
     if (strstr(filename.c_str(), ".x3d")) 
         {
-                return ReplaceSuffix(filename, ".x3d", ".kd");
+                return ReplaceSuffix(filename, ".x3d", suffix);
         } 
         else if (strstr(filename.c_str(), ".dat"))
         {
-                return ReplaceSuffix(filename, ".dat", ".kd");
+                return ReplaceSuffix(filename, ".dat", suffix);
         } 
         else if (strstr(filename.c_str(), ".obj"))
         {
-                return ReplaceSuffix(filename, ".dat", ".kd");
+                return ReplaceSuffix(filename, ".dat", suffix);
         }