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

Revision 1740, 3.6 KB checked in by mattausch, 18 years ago (diff)

exchanged pvs implementation: using vectors instead of maps

Line 
1#include <iostream>
2#include <stack>
3#include "Pvs.h"
4#include "Intersectable.h"
5#include "IntersectableWrapper.h"
6#include "KdTree.h"
7#include "common.h"
8#include "BvHierarchy.h"
9
10
11namespace GtpVisibilityPreprocessor {
12
13int MailablePvsData::sMailId = 1;
14int MailablePvsData::sReservedMailboxes = 1;
15
16
17int KdPvs::Compress()
18{
19        return 0; // TODO
20}
21
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 EvalKdNodeContribution(KdIntersectable *kdobj)
26{
27        int pvs = 0;
28        stack<KdNode *> tStack;
29
30        tStack.push(kdobj->GetItem());
31
32        while (!tStack.empty())
33        {
34                KdNode *node = tStack.top();
35                tStack.pop();
36
37                // already processed node (=> objects already in pvs)?
38                if (!node->Mailed())
39                {
40                        node->Mail();
41
42                        if (node->IsLeaf())
43                        {
44                                KdLeaf *leaf = dynamic_cast<KdLeaf *>(node);
45                       
46                                // add #objects exclusivly in this node
47                                pvs += (int)(leaf->mObjects.size() - leaf->mMultipleObjects.size());
48
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)
54                                {
55                                        Intersectable *object = *oit;                                           
56                           
57                                        if (!object->Mailed())
58                                        {
59                                                object->Mail();
60                                                ++ pvs;
61                                        }
62                                }
63                        }
64                        else // traverse tree
65                        {
66                                KdInterior *interior = dynamic_cast<KdInterior *>(node);
67
68                                tStack.push(interior->mFront);
69                                tStack.push(interior->mBack);
70                        }
71                }
72        }
73
74        return pvs;
75}
76
77
78/** Returns the the number of new (unmailed) objects in the leaves of the node.
79        We eliminate already accounted bvh nodes and objects using mailboxing.
80*/
81static float EvalBvhNodeContribution(BvhIntersectable *bvhobj)
82{
83        BvhLeaf *leaf = bvhobj->GetItem();
84        BvhNode *node = leaf->GetActiveNode();
85
86        // early exit
87        if (node == leaf)       
88        {
89                // objects already accounted for
90                if (leaf->Mailed())
91                        return 0;
92
93                leaf->Mail();
94                return BvHierarchy::EvalAbsCost(leaf->mObjects);
95        }                       
96
97        // compute leaf pvs
98        float pvs = 0;
99        stack<BvhNode *> tStack;
100        tStack.push(node);
101
102        while (!tStack.empty())
103        {
104                node = tStack.top();
105                tStack.pop();
106
107                // already processed node (=> objects already in pvs)?
108                if (!node->Mailed())
109                {
110                        node->Mail();
111
112                        if (node->IsLeaf())
113                        {
114                                leaf = dynamic_cast<BvhLeaf *>(node);
115
116                                // add #objects exclusivly in this node
117                                pvs += BvHierarchy::EvalAbsCost(leaf->mObjects);
118                        }
119                        else // traverse tree
120                        {
121                                BvhInterior *interior = dynamic_cast<BvhInterior *>(node);
122
123                                tStack.push(interior->GetFront());
124                                tStack.push(interior->GetBack());
125                        }
126                }
127        }
128
129        return pvs;
130}
131
132
133float ObjectPvs::EvalPvsCost() const
134{
135        float pvs = 0;
136
137        Intersectable::NewMail();
138        KdLeaf::NewMail();
139        BvhLeaf::NewMail();
140
141        ObjectPvsEntries::const_iterator it, it_end = mEntries.end();
142
143        for (it = mEntries.begin(); it != it_end; ++ it)
144        {
145                Intersectable *obj = (*it).mObject;
146       
147                switch (obj->Type())
148                {
149                        case Intersectable::KD_INTERSECTABLE:
150                                {
151                                        // found kd node
152                                        KdIntersectable *kdObj = dynamic_cast<KdIntersectable *>(obj);
153                                        pvs += EvalKdNodeContribution(kdObj);   
154                                        break;
155                                }
156                        case Intersectable::BVH_INTERSECTABLE:
157                                {
158                                        BvhIntersectable *bvhObj = dynamic_cast<BvhIntersectable *>(obj);
159                                        pvs += EvalBvhNodeContribution(bvhObj);
160                                        break;
161                                }
162                        default:
163                                ++ pvs;
164                                break;
165                }
166        }
167
168        return pvs;
169}
170
171}
Note: See TracBrowser for help on using the repository browser.