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

Revision 1233, 3.6 KB checked in by mattausch, 18 years ago (diff)
RevLine 
[177]1#include <iostream>
[1141]2#include <stack>
[177]3#include "Pvs.h"
[1141]4#include "Intersectable.h"
5#include "KdIntersectable.h"
6#include "KdTree.h"
7#include "common.h"
[1233]8#include "BvHierarchy.h"
[177]9
[1141]10
[863]11namespace GtpVisibilityPreprocessor {
[860]12
[1189]13int MailablePvsData::sMailId = 1;
14int MailablePvsData::sReservedMailboxes = 1;
[1141]15
[1189]16
[1141]17int KdPvs::Compress()
[177]18{
[311]19        return 0; // TODO
[860]20}
21
[1233]22/** the pvs is the number of different objects in the node leaves
23        We eliminate already accounted kd nodes and objects using mailboxing.
24*/
25static int CountNewObjectsInKdNode(KdIntersectable *kdobj)
[1141]26{
27        int pvs = 0;
[1233]28        stack<KdNode *> tStack;
[1141]29
[1233]30        tStack.push(kdobj->GetItem());
[1141]31
[1233]32        while (!tStack.empty())
[1141]33        {
[1233]34                KdNode *node = tStack.top();
35                tStack.pop();
[1141]36
[1233]37                // already processed node (=> objects already in pvs)?
38                if (!node->Mailed())
[1141]39                {
[1233]40                        node->Mail();
[1141]41
[1233]42                        if (node->IsLeaf())
[1141]43                        {
[1233]44                                KdLeaf *leaf = dynamic_cast<KdLeaf *>(node);
45                       
46                                // add #objects exclusivly in this node
47                                pvs += (int)(leaf->mObjects.size() - leaf->mMultipleObjects.size());
[1141]48
[1233]49                                // Objects already accounted for can only be found among those
50                                // which are referenced in more than one leaf
51                                ObjectContainer::const_iterator oit, oit_end = leaf->mMultipleObjects.end();
52                                               
53                                for (oit = leaf->mMultipleObjects.begin(); oit != oit_end; ++ oit)
[1141]54                                {
[1233]55                                        Intersectable *object = *oit;                                           
[1168]56                           
[1233]57                                        if (!object->Mailed())
[1168]58                                        {
[1233]59                                                object->Mail();
60                                                ++ pvs;
[1168]61                                        }
[1141]62                                }
63                        }
[1233]64                        else // traverse tree
65                        {
66                                KdInterior *interior = dynamic_cast<KdInterior *>(node);
67
68                                tStack.push(interior->mFront);
69                                tStack.push(interior->mBack);
70                        }
[1141]71                }
[1233]72        }
73
74        return pvs;
75}
76
77
78/** the pvs is the number of different objects in the node leaves
79        We eliminate already accounted kd nodes and objects using mailboxing.
80*/
81static int CountNewObjectsInBvhNode(BvhIntersectable *bvhobj)
82{
83        BvhNode *node= bvhobj->GetItem();
84
85        // early exit
86        if (node->IsLeaf())     
87        {
88                if (!node->Mailed())
89                {
90                        node->Mail();
91                        return (int)(((BvhLeaf *)node)->mObjects.size());
92                }
[1141]93                else
94                {
[1233]95                        return 0;
[1141]96                }
97        }
[1233]98                                 
[1141]99
[1233]100        // compute leaf pvs
101        int pvs = 0;
102
103        stack<BvhNode *> tStack;
104
105        tStack.push(bvhobj->GetItem());
106
107        while (!tStack.empty())
108        {
109                BvhNode *node = tStack.top();
110                tStack.pop();
111
112                // already processed node (=> objects already in pvs)?
113                if (!node->Mailed())
114                {
115                        node->Mail();
116
117                        if (node->IsLeaf())
118                        {
119                                BvhLeaf *leaf = dynamic_cast<BvhLeaf *>(node);
120                       
121                                // add #objects exclusivly in this node
122                                pvs += leaf->mObjects.size();
123                        }
124                        else // traverse tree
125                        {
126                                BvhInterior *interior = dynamic_cast<BvhInterior *>(node);
127
128                                tStack.push(interior->GetFront());
129                                tStack.push(interior->GetBack());
130                        }
131                }
132        }
[1141]133        return pvs;
134}
135
[1233]136
137
138int ObjectPvs::CountObjectsInPvs() const
139{
140        int pvs = 0;
141
142        Intersectable::NewMail();
143        KdLeaf::NewMail();
144        BvhLeaf::NewMail();
145
146        ObjectPvsMap::const_iterator it, it_end = mEntries.end();
147
148        for (it = mEntries.begin(); it != it_end; ++ it)
149        {
150                Intersectable *obj = (*it).first;
151
152                switch (obj->Type())
153                {
154                        case Intersectable::KD_INTERSECTABLE:
155                                {
156                                        // found kd node
157                                        KdIntersectable *kdObj = dynamic_cast<KdIntersectable *>(obj);
158                                        pvs += CountNewObjectsInKdNode(kdObj); 
159                                        break;
160                                }
161                        case Intersectable::BVH_INTERSECTABLE:
162                                {
163                                        BvhIntersectable *bvhObj = dynamic_cast<BvhIntersectable *>(obj);
164                                        pvs += CountNewObjectsInBvhNode(bvhObj);
165                                        break;
166                                }
167                        default:
168                                ++ pvs;
169                                break;
170                }
171        }
172
173        return pvs;
174}
175
[311]176}
Note: See TracBrowser for help on using the repository browser.