source: GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.cpp @ 1314

#include <stack>
#include <time.h>
#include <iomanip>

#include "ViewCell.h"
#include "Plane3.h"
#include "HierarchyManager.h"
#include "Mesh.h"
#include "common.h"
#include "Environment.h"
#include "Polygon3.h"
#include "Ray.h"
#include "AxisAlignedBox3.h"
#include "Exporter.h"
#include "Plane3.h"
#include "ViewCellsManager.h"
#include "Beam.h"
#include "KdTree.h"
#include "KdIntersectable.h"
#include "VspTree.h"
#include "OspTree.h"
#include "BvHierarchy.h"


namespace GtpVisibilityPreprocessor {


#define USE_FIXEDPOINT_T 0


/*******************************************************************/
/*              class HierarchyManager implementation              */
/*******************************************************************/


HierarchyManager::HierarchyManager(VspTree *vspTree, 
                                                                   const int objectSpaceSubdivisionType):
mObjectSpaceSubdivisionType(objectSpaceSubdivisionType),
mVspTree(vspTree), 
mOspTree(NULL), 
mBvHierarchy(NULL)
{
        switch(mObjectSpaceSubdivisionType)
        {
        case KD_BASED_OBJ_SUBDIV:
                mOspTree = new OspTree();
                mOspTree->mVspTree = mVspTree;
                //mOspTree->mHierarchyManager = this;
                Debug << "creating osp tree" << endl;
                break;
        case BV_BASED_OBJ_SUBDIV:
        mBvHierarchy = new BvHierarchy();
                mBvHierarchy->mVspTree = mVspTree;
                //mBvHierarchy->mHierarchyManager = this;
                Debug << "creating bv hierachy" << endl;
                break;
        default:
                break;
        }

        if (mVspTree)
                mVspTree->mHierarchyManager = this;

        ParseEnvironment();
}


HierarchyManager::HierarchyManager(VspTree *vspTree, KdTree *kdTree): 
mObjectSpaceSubdivisionType(KD_BASED_OBJ_SUBDIV),
mVspTree(vspTree), 
mBvHierarchy(NULL)
{
        mOspTree = new OspTree(*kdTree);
        mOspTree->mVspTree = mVspTree;

        //mOspTree->mHierarchyManager = this;
        Debug << "creating osp tree" << endl;

        if (mVspTree)
                mVspTree->mHierarchyManager = this;

        ParseEnvironment();
}


void HierarchyManager::ParseEnvironment()
{
        char subdivisionStatsLog[100];
        Environment::GetSingleton()->GetStringValue("Hierarchy.subdivisionStats", 
                subdivisionStatsLog);
        mSubdivisionStats.open(subdivisionStatsLog);

        Environment::GetSingleton()->GetFloatValue(
                "Hierarchy.Termination.minGlobalCostRatio", mTermMinGlobalCostRatio);
        Environment::GetSingleton()->GetIntValue(
                "Hierarchy.Termination.globalCostMissTolerance", mTermGlobalCostMissTolerance);

        Environment::GetSingleton()->GetIntValue(
                "Hierarchy.Termination.maxLeaves", mTermMaxLeaves);

        Environment::GetSingleton()->GetIntValue(
                "Hierarchy.Construction.type", mConstructionType);

        Environment::GetSingleton()->GetIntValue(
                "Hierarchy.Construction.minDepthForOsp", mMinDepthForObjectSpaceSubdivion);
        
        Environment::GetSingleton()->GetBoolValue(
                "Hierarchy.Construction.repairQueue", mRepairQueue);

        Debug << "******** Hierachy Manager Parameters ***********" << endl;
        Debug << "max leaves: " << mTermMaxLeaves << endl;
        Debug << "min global cost ratio: " << mTermMinGlobalCostRatio << endl;
        Debug << "global cost miss tolerance: " << mTermGlobalCostMissTolerance << endl;
        Debug << "construction type: " << mConstructionType << endl;
        Debug << "min depth for object space subdivision: " << mMinDepthForObjectSpaceSubdivion << endl;
        Debug << "repair queue: " << mRepairQueue << endl;
}


HierarchyManager::~HierarchyManager()
{
        DEL_PTR(mOspTree);
        //DEL_PTR(mVspTree);
        DEL_PTR(mBvHierarchy);
}


void HierarchyManager::SetViewCellsManager(ViewCellsManager *vcm)
{
        mVspTree->SetViewCellsManager(vcm);

        if (mOspTree)
                mOspTree->SetViewCellsManager(vcm);
        if (mBvHierarchy)
                mBvHierarchy->SetViewCellsManager(vcm);
}


void HierarchyManager::SetViewCellsTree(ViewCellsTree *vcTree)
{
        mVspTree->SetViewCellsTree(vcTree);
}


SubdivisionCandidate *HierarchyManager::NextSubdivisionCandidate()
{
        SubdivisionCandidate *splitCandidate = mTQueue.Top();
        mTQueue.Pop();

        return splitCandidate;
}


void HierarchyManager::EvalSubdivisionStats(const SubdivisionCandidate &tData)
{
        const float costDecr = tData.GetRenderCostDecrease();

        switch (mObjectSpaceSubdivisionType)
        {
        case KD_BASED_OBJ_SUBDIV:
                AddSubdivisionStats(mOspTree->mOspStats.Leaves() + mVspTree->mVspStats.Leaves(),
                                                        costDecr,
                                                        mTotalCost
                                                        );
                break;
        case BV_BASED_OBJ_SUBDIV:
                AddSubdivisionStats(mBvHierarchy->mBvhStats.Leaves() + mVspTree->mVspStats.Leaves(),
                                                        costDecr,
                                                        mTotalCost
                                                        );
                break;
        default:
                AddSubdivisionStats(mVspTree->mVspStats.Leaves(),
                                                        costDecr,
                                                        mTotalCost
                                                        );
                break;
        }
}


void HierarchyManager::AddSubdivisionStats(const int splits,
                                                                                   const float renderCostDecr,
                                                                                   const float totalRenderCost)
{
        mSubdivisionStats
                        << "#Splits\n" << splits << endl
                        << "#RenderCostDecrease\n" << renderCostDecr << endl 
                        << "#TotalRenderCost\n" << totalRenderCost << endl;
                        //<< "#AvgRenderCost\n" << avgRenderCost << endl;
}


bool HierarchyManager::GlobalTerminationCriteriaMet(SubdivisionCandidate *candidate) const
{
        return (0
                || (mHierarchyStats.Leaves() >= mTermMaxLeaves) 
                //|| (mGlobalCostMisses >= mTermGlobalCostMissTolerance)
                ||      candidate->GlobalTerminationCriteriaMet()
                );
}


void HierarchyManager::Construct(const VssRayContainer &sampleRays,
                                                                 const ObjectContainer &objects,
                                                                 AxisAlignedBox3 *forcedViewSpace)
{
        
        mHierarchyStats.Reset();
        mHierarchyStats.Start();
        
        mTotalCost = (float)objects.size();
        Debug << "setting total cost to " << mTotalCost << endl;

        const long startTime = GetTime();
        cout << "Constructing view space / object space tree ... \n";
        
        // process object space candidates
        RunConstruction(sampleRays, objects, forcedViewSpace);
        
        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
        mHierarchyStats.Stop();
        mVspTree->mVspStats.Stop();
}


void HierarchyManager::PrepareViewSpaceSubdivision(const VssRayContainer &sampleRays,
                                                                                                   const ObjectContainer &objects,
                                                                                                   AxisAlignedBox3 *forcedViewSpace)
{
        RayInfoContainer *viewSpaceRays = new RayInfoContainer();
        SubdivisionCandidate *vsc = 
                mVspTree->PrepareConstruction(sampleRays, forcedViewSpace, *viewSpaceRays);

        mTQueue.Push(vsc);
}


void HierarchyManager::PrepareObjectSpaceSubdivision(const VssRayContainer &sampleRays,
                                                                                                         const ObjectContainer &objects)
{
        if (mObjectSpaceSubdivisionType == KD_BASED_OBJ_SUBDIV)
        {
                PrepareOspTree(sampleRays, objects);
        }
        else if (mObjectSpaceSubdivisionType == BV_BASED_OBJ_SUBDIV)
        {
                PrepareBvHierarchy(sampleRays, objects);
        }
}


void HierarchyManager::PrepareBvHierarchy(const VssRayContainer &sampleRays,
                                                                                  const ObjectContainer &objects) 

{
        cout << "starting bv hierarchy construction ... " << endl;

        mBvHierarchy->CreateRoot(objects);

        // compute first candidate
        SubdivisionCandidate *sc =
                mBvHierarchy->PrepareConstruction(sampleRays, objects);

        mTotalCost = mBvHierarchy->mTotalCost;
        Debug << "reseting cost, new total cost: " << mTotalCost << endl;

    mTQueue.Push(sc);
}


void HierarchyManager::PrepareOspTree(const VssRayContainer &sampleRays,
                                                                          const ObjectContainer &objects)
{
        RayInfoContainer *objectSpaceRays = new RayInfoContainer();

        cout << "starting osp tree construction ... " << endl;

        // start with one big kd cell - all objects can be seen from everywhere
        // note: only true for view space = object space

        // compute first candidate
        SubdivisionCandidate *osc =
                mOspTree->PrepareConstruction(sampleRays, objects, *objectSpaceRays);

        mTotalCost = mOspTree->mTotalCost;
        Debug << "reseting cost, new total cost: " << mTotalCost << endl;
        
    mTQueue.Push(osc);
}


bool HierarchyManager::ApplySubdivisionCandidate(SubdivisionCandidate *sc)
{
        const bool globalTerminationCriteriaMet = GlobalTerminationCriteriaMet(sc);
        const bool vspSplit = (sc->Type() == SubdivisionCandidate::VIEW_SPACE);

        if (vspSplit)
        {
                VspNode *n = mVspTree->Subdivide(mTQueue, sc, globalTerminationCriteriaMet);

                if (n->IsLeaf()) // local or global termination criteria failed
                        return false;
        }
        else
        {
                if (mObjectSpaceSubdivisionType == KD_BASED_OBJ_SUBDIV)
                {
                        KdNode *n = mOspTree->Subdivide(mTQueue, sc, globalTerminationCriteriaMet);

                        if (n->IsLeaf()) // local or global termination criteria failed
                                return false;
                }
                else if (mObjectSpaceSubdivisionType == BV_BASED_OBJ_SUBDIV)
                {
                        BvhNode *n = mBvHierarchy->Subdivide(mTQueue, sc, globalTerminationCriteriaMet);

                        if (n->IsLeaf()) // local or global termination criteria failed
                                return false;
                }
        }
        return true;//!globalTerminationCriteriaMet;
}


bool HierarchyManager::StartObjectSpaceSubdivision() const
{
        const bool ospDepthReached = 
                (mMinDepthForObjectSpaceSubdivion <= mVspTree->mVspStats.maxDepth);
        const bool stillNotOsp = (mObjectSpaceSubdivisionType == NO_OBJ_SUBDIV);
    
        return stillNotOsp && (mTQueue.Empty() || ((mConstructionType == 1) && ospDepthReached));
}


void HierarchyManager::RunConstruction(const VssRayContainer &sampleRays,
                                                                           const ObjectContainer &objects,
                                                                           AxisAlignedBox3 *forcedViewSpace)
{
        mHierarchyStats.nodes = 0;
        mGlobalCostMisses = 0;

        // use objects for evaluating vsp tree construction in the first levels
        // of the subdivision
        const int savedObjectSpaceSubdivisionType = mObjectSpaceSubdivisionType;
        mObjectSpaceSubdivisionType = NO_OBJ_SUBDIV;

        // start with view space subdivison: prepare vsp tree for traversal
        PrepareViewSpaceSubdivision(sampleRays, objects, forcedViewSpace);

        // start object space subdivision immediately?
        if (StartObjectSpaceSubdivision())
        {cout << "here1155 ";
                mObjectSpaceSubdivisionType = savedObjectSpaceSubdivisionType;
                PrepareObjectSpaceSubdivision(sampleRays, objects);
        }

        int i = 0;
        while (!FinishedConstruction())
        {
                mCurrentCandidate = NextSubdivisionCandidate();    
                mTotalCost -= mCurrentCandidate->GetRenderCostDecrease();

                // cost ratio of cost decrease / totalCost
                const float costRatio = mCurrentCandidate->GetRenderCostDecrease() / mTotalCost;

                //Debug << "ratio: " << costRatio << " min ratio: " << mTermMinGlobalCostRatio << endl;
                if (costRatio < mTermMinGlobalCostRatio)
                {
                        ++ mGlobalCostMisses;
                }
                
                //-- subdivide leaf node
                if (ApplySubdivisionCandidate(mCurrentCandidate))
                {
                        cout << "subdividing candidate " << ++ i << " of type " << mCurrentCandidate->Type() << endl;
                        mHierarchyStats.nodes += 2;

                        // subdivision successful
                        EvalSubdivisionStats(*mCurrentCandidate);
                
                        // reevaluate candidates affected by the split for view space splits, 
                        // this would be object space splits and other way round
                        if (mRepairQueue) RepairQueue();
                }

                // we use objects for evaluating vsp tree construction until 
                // a certain depth once a certain depth existiert ....
                if (StartObjectSpaceSubdivision())
                {
                        mObjectSpaceSubdivisionType = savedObjectSpaceSubdivisionType;

                        cout << "starting object space subdivision at maximal view space subdivison depth " << mVspTree->mVspStats.maxDepth << " (" << mMinDepthForObjectSpaceSubdivion << ") " << endl;
                        PrepareObjectSpaceSubdivision(sampleRays, objects);

                        cout << "reseting queue ... ";
                        ResetQueue();
                        cout << "finished" << endl;
                }

                DEL_PTR(mCurrentCandidate);
        }
        
        mObjectSpaceSubdivisionType = savedObjectSpaceSubdivisionType;
}


bool HierarchyManager::FinishedConstruction() const
{
        return mTQueue.Empty();
}


bool HierarchyManager::ObjectSpaceSubdivisionConstructed() const
{
        switch (mObjectSpaceSubdivisionType)
        {
        case KD_BASED_OBJ_SUBDIV:
                return mOspTree && mOspTree->GetRoot();
        case BV_BASED_OBJ_SUBDIV:
                return mBvHierarchy && mOspTree->GetRoot();
        default:
        return false;
        }
}


void HierarchyManager::CollectObjectSpaceDirtyList(SubdivisionCandidateContainer &dirtyList)
{
        switch (mObjectSpaceSubdivisionType)
        {
        case KD_BASED_OBJ_SUBDIV:
                {
                        OspTree::OspSubdivisionCandidate *sc = 
                                dynamic_cast<OspTree::OspSubdivisionCandidate *>(mCurrentCandidate);

                        mOspTree->CollectDirtyCandidates(sc, dirtyList);
                        break;
                }
        case BV_BASED_OBJ_SUBDIV:
                {
                        BvHierarchy::BvhSubdivisionCandidate *sc = 
                                dynamic_cast<BvHierarchy::BvhSubdivisionCandidate *>(mCurrentCandidate);

                        mBvHierarchy->CollectDirtyCandidates(sc, dirtyList);
                        break;
                }
        default:
                break;
        }
}


void HierarchyManager::CollectViewSpaceDirtyList(SubdivisionCandidateContainer &dirtyList)
{
        VspTree::VspSubdivisionCandidate *sc = 
                dynamic_cast<VspTree::VspSubdivisionCandidate *>(mCurrentCandidate);

        mVspTree->CollectDirtyCandidates(sc, dirtyList);
}


void HierarchyManager::CollectDirtyCandidates(SubdivisionCandidateContainer &dirtyList)
{
        // we have either a object space or view space split
        if (mCurrentCandidate->Type() == SubdivisionCandidate::VIEW_SPACE)
        {
                CollectViewSpaceDirtyList(dirtyList);
        }
        else // object space split
        {
                CollectObjectSpaceDirtyList(dirtyList);
        }
}


void HierarchyManager::RepairQueue()
{
        // for each update of the view space partition:
        // the candidates from object space partition which
        // have been afected by the view space split (the kd split candidates
        // which saw the view cell which was split) must be reevaluated 
        // (maybe not locally, just reinsert them into the queue)
        //
        // vice versa for the view cells
        // for each update of the object space partition
        // reevaluate split candidate for view cells which saw the split kd cell
        // 
        // the priority queue update can be solved by implementing a binary heap
        // (explicit data structure, binary tree)
        // *) inserting and removal is efficient
        // *) search is not efficient => store queue position with each
        // split candidate

        // collect list of "dirty" candidates
        long startTime = GetTime();
   
        vector<SubdivisionCandidate *> dirtyList;
        CollectDirtyCandidates(dirtyList);
        cout << "repairing " << (int)dirtyList.size() << " candidates ... ";
        
        //-- reevaluate the dirty list
        SubdivisionCandidateContainer::const_iterator sit, sit_end = dirtyList.end();
        
        for (sit = dirtyList.begin(); sit != sit_end; ++ sit)
        {
                SubdivisionCandidate* sc = *sit;
                const float rcd = sc->GetRenderCostDecrease();
                
                mTQueue.Erase(sc); // erase from queue
                sc->EvalPriority(); // reevaluate
                
                /*
                Debug << "candidate " << sc << " reevaluated\n" 
                          << "render cost decrease diff " <<  rcd - sc->GetRenderCostDecrease()
                          << " old: " << rcd << " new " << sc->GetRenderCostDecrease() << endl;*/
                if (0)
                {
                        const float rcDiff =  rcd - sc->GetRenderCostDecrease();
                        mTotalCost += rcDiff;
                }
                mTQueue.Push(sc); // reinsert
        }

        long endTime = GetTime();
        Real timeDiff = TimeDiff(startTime, endTime);

        mHierarchyStats.repairTime += timeDiff;

        cout << "finished in " << timeDiff * 1e-3f << " secs" << endl;
}


void HierarchyManager::ResetQueue()
{
        SubdivisionCandidateContainer mCandidateBuffer;

        // remove from queue
        while (!mTQueue.Empty())
        {
                SubdivisionCandidate *candidate = NextSubdivisionCandidate();
                candidate->EvalPriority(); // reevaluate
                cout << ".";
                mCandidateBuffer.push_back(candidate);
        }

        // put back into queue
        SubdivisionCandidateContainer::const_iterator sit, sit_end = mCandidateBuffer.end();
    for (sit = mCandidateBuffer.begin(); sit != sit_end; ++ sit)
        {cout << ":";
                mTQueue.Push(*sit);
        }
}


void HierarchyManager::ExportObjectSpaceHierarchy(OUT_STREAM &stream)
{
        // the type of the view cells hierarchy
        switch (mObjectSpaceSubdivisionType)
        {
        case KD_BASED_OBJ_SUBDIV:
                stream << "<ObjectSpaceHierarchy type=\"osp\">" << endl;
                mOspTree->Export(stream);
                stream << endl << "</ObjectSpaceHierarchy>" << endl;
                break;          
        case BV_BASED_OBJ_SUBDIV:
                stream << "<ObjectSpaceHierarchy type=\"bvh\">" << endl;
                mBvHierarchy->Export(stream);
                stream << endl << "</ObjectSpaceHierarchy>" << endl;
                break;
        }
}


bool HierarchyManager::AddSampleToPvs(Intersectable *obj, 
                                                                          const Vector3 &hitPoint,
                                                                          ViewCell *vc,
                                                                          const float pdf, 
                                                                          float &contribution) const
{
        if (!obj) return false;

        switch (mObjectSpaceSubdivisionType)
        {
        case NO_OBJ_SUBDIV:
                // potentially visible objects
                return vc->AddPvsSample(obj, pdf, contribution);
        case KD_BASED_OBJ_SUBDIV:
                {
                        // potentially visible kd cells
                        KdLeaf *leaf = mOspTree->GetLeaf(hitPoint/*ray->mOriginNode*/);
                        return mOspTree->AddLeafToPvs(leaf, vc, pdf, contribution);
                }
        case BV_BASED_OBJ_SUBDIV:
                {
                        BvhLeaf *leaf = mBvHierarchy->GetLeaf(obj);
                        return mBvHierarchy->AddLeafToPvs(leaf, vc, pdf, contribution);
                }
        default:
                return false;
        }
}


void HierarchyManager::PrintHierarchyStatistics(ofstream &stream) const
{
        stream << mHierarchyStats << endl;

        stream << "\nview space:" << endl << endl;
        stream << mVspTree->GetStatistics() << endl;
        stream << "\nobject space:" << endl << endl;
        switch (mObjectSpaceSubdivisionType)
        {
        case KD_BASED_OBJ_SUBDIV:
                {
                        stream << mOspTree->GetStatistics() << endl;
                        break;
                }
        case BV_BASED_OBJ_SUBDIV:
                {
                        stream << mBvHierarchy->GetStatistics() << endl;
                        break;
                }
        default:
                break;
        }
}


void HierarchyManager::ExportObjectSpaceHierarchy(Exporter *exporter,
                                                                                                  const ObjectContainer &objects) const
{
        switch (mObjectSpaceSubdivisionType)
        {
        case KD_BASED_OBJ_SUBDIV:
                {
                        ExportOspTree(exporter, objects);
                        break;
                }
        case BV_BASED_OBJ_SUBDIV:
                {
                        ExportBvHierarchy(exporter, objects);
                        break;
                }
        default:
                break;
        }
}


void HierarchyManager::ExportBvHierarchy(Exporter *exporter, 
                                                                                 const ObjectContainer &objects) const
{
        exporter->SetWireframe();
        exporter->ExportBvHierarchy(*mBvHierarchy, 0);
}


void HierarchyManager::ExportOspTree(Exporter *exporter, 
                                                                         const ObjectContainer &objects) const
{
        if (0) exporter->ExportGeometry(objects);
                        
        exporter->SetWireframe();
        exporter->ExportOspTree(*mOspTree, 0);
}


void HierarchyStatistics::Print(ostream &app) const
{
        app << "=========== Hierarchy statistics ===============\n";

        app << setprecision(4);

        app << "#N_CTIME  ( Construction time [s] )\n" << Time() << " \n";
        
        app << "#N_RTIME  ( Repair time [s] )\n" << repairTime * 1e-3f << " \n";

        app << "#N_NODES ( Number of nodes )\n" << nodes << "\n";

        app << "#N_INTERIORS ( Number of interior nodes )\n" << Interior() << "\n";

        app << "#N_LEAVES ( Number of leaves )\n" << Leaves() << "\n";

        app << "#N_PMAXDEPTH ( Maximal reached depth )\n" << maxDepth << endl;
        
        app << "========== END OF Hierarchy statistics ==========\n";
}


}