Changeset 1633 for GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.cpp

Timestamp:

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

Author:

mattausch

Message:

worked on gradient method for vsposp

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.cpp (modified) (18 diffs)

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;
 }