source: GTP/trunk/Lib/Vis/Preprocessing/src/Pvs.cpp @ 1143

#include <iostream>
#include <stack>
#include "Pvs.h"
#include "Intersectable.h"
#include "KdIntersectable.h"
#include "KdTree.h"
#include "common.h"


namespace GtpVisibilityPreprocessor {


int KdPvs::Compress()
{
        return 0; // TODO
}


int ObjectPvs::CountPvs() const
{
        int pvs = 0;

        Intersectable::NewMail();
        KdNode::NewMail();

        ObjectPvsMap::const_iterator it, it_end = mEntries.end();

        for (it = mEntries.begin(); it != it_end; ++ it)
        {
                Intersectable *obj = (*it).first;

                // found kd node
                // the pvs is the sum of the objects in the leaves in the subtree
                // We eliminate already accounted kd nodes and objects
                // using mailboxing. 
                if (obj->Type() == Intersectable::KD_INTERSECTABLE)
                {
                        KdIntersectable *kdObj = dynamic_cast<KdIntersectable *>(obj);

                        stack<KdNode *> tStack;

                        tStack.push(kdObj->GetNode());

                        while (!tStack.empty())
                        {
                                KdNode *node = tStack.top();
                                tStack.pop();

                                // already processed node (objects in pvs)
                                if (node->Mailed())
                                        continue;

                                node->Mail();

                                if (node->IsLeaf())
                                {
                                        KdLeaf *leaf = dynamic_cast<KdLeaf *>(node);

                                        pvs += (int)(leaf->mObjects.size() - leaf->mMultipleObjects.size());

                                        // Objects already accounted for can only be found among those
                                        // which are referenced in more than one leaf
                                        ObjectContainer::const_iterator oit, oit_end = leaf->mMultipleObjects.end();
                                        for (oit = leaf->mMultipleObjects.begin(); oit != oit_end; ++ oit)
                                        {
                                                Intersectable *object = *oit;                                           
                                                
                                                if (!object->Mailed())
                                                {
                                                        object->Mail();
                                                        ++ pvs;
                                                }
                                        }
                                }
                                else
                                {
                                        KdInterior *interior = dynamic_cast<KdInterior *>(node);

                                        tStack.push(interior->mFront);
                                        tStack.push(interior->mBack);
                                }
                        }
                }
                else
                {
                        ++ pvs;
                }
        }

        return pvs;
}

}