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

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


namespace GtpVisibilityPreprocessor {

int MailablePvsData::sMailId = 1;
int MailablePvsData::sReservedMailboxes = 1;


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


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

        Intersectable::NewMail();
        KdLeaf::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 number od different objects in the node leaves
                // 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 (0 ||!node->Mailed())
                                {
                                        node->Mail();

                                        if (node->IsLeaf())
                                        {
                                                KdLeaf *leaf = dynamic_cast<KdLeaf *>(node);
#if 1                        
                                                // add #objects exclusivly in this 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   
                                                ObjectContainer::const_iterator oit, oit_end = leaf->mObjects.end();
                                                
                                                for (oit = leaf->mObjects.begin(); oit != oit_end; ++ oit)
                                                {
                                                        Intersectable *object = *oit;                                           
                            
                                                        if (!object->Mailed())
                                                        {
                                                                object->Mail();
                                                                ++ pvs;
                                                        }
                                                }
#endif
                                        }
                                        else // traverse tree
                                        {
                                                KdInterior *interior = dynamic_cast<KdInterior *>(node);

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

        return pvs;
}

}