Changeset 2124 for GTP/trunk/Lib/Vis/Preprocessing/src/TraversalTree.h

Timestamp:

02/19/07 02:51:22 (17 years ago)

Author:

mattausch

Message:

 

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/TraversalTree.h (modified) (11 diffs)

GTP/trunk/Lib/Vis/Preprocessing/src/TraversalTree.h

@@ -8 +8 @@
 #include "AxisAlignedBox3.h"
 #include "Ray.h"
-//#include "ObjectPvs.h"
-//#include "Viewcell.h"
-//#include "VssRay.h"
-//#include "IntersectableWrapper.h"
 
 
@@ -25 +21 @@
 class TraversalTree;
   
-//  TraversalTree *SceneTraversalTree;
 
 // --------------------------------------------------------------
@@ -55 +50 @@
   // max number of rays per node
   int maxObjectRefs;
+  // max number of rays per node
+  int totalObjectRefs;
   // number of dynamically added ray refs
   int addedRayRefs;
@@ -83 +80 @@
           minCostNodes = 0;
           maxObjectRefs = 0;
+          totalObjectRefs = 0;
           addedRayRefs = removedRayRefs = 0;
   }
@@ -121 +119 @@
         }
 
-        /** Parent of the node - the parent is a little overhead for maintanance of the tree,
-                but allows various optimizations of tree traversal algorithms 
+        /** Parent of the node - the parent is a little overhead for 
+                maintanance of the tree, but allows various optimizations 
+                of tree traversal algorithms 
         */
         TraversalInterior *mParent;
@@ -217 +216 @@
 
         // pointers to view cells contained in this node
-        ObjectContainer mObjects;
+        ViewCellContainer mViewCells;
 
         short mDepth;
@@ -237 +236 @@
                 float mPriority;
 
-                TraversalData() {}
+                TraversalData(): mNode(NULL), mPriority(0), mDepth(0) {}
 
                 TraversalData(TraversalNode *n, const float p):
-                mNode(n), mPriority(p)
+                mNode(n), mPriority(p), mDepth(0)
                 {}
 
                 TraversalData(TraversalNode *n,
-                        const AxisAlignedBox3 &b,
-                        const int d):
-                mNode(n), mBox(b), mDepth(d) {}
+                                          const AxisAlignedBox3 &b,
+                                          const int d):
+                mNode(n), mBox(b), mDepth(d) 
+                {}
 
 
@@ -255 +255 @@
                         
                         return 
-                                leafa->mObjects.size() * mBox.SurfaceArea()
+                                leafa->mViewCells.size() * mBox.SurfaceArea()
                                 <
-                                leafb->mObjects.size() * b.mBox.SurfaceArea();
+                                leafb->mViewCells.size() * b.mBox.SurfaceArea();
                 }
 
 
-                        // comparator for the 
-                        struct less_priority: public 
+                // comparator for the 
+                struct less_priority: public 
                                 binary_function<const TraversalData, const TraversalData, bool> 
+                {
+                        bool operator()(const TraversalData a, const TraversalData b) 
                         {
-                bool operator()(const TraversalData a, const TraversalData b) 
-                                {
-                                        return a.mPriority < b.mPriority;
-                                }
-            };
+                                return a.mPriority < b.mPriority;
+                        }
+                };
         };
 
@@ -292 +292 @@
                                                 const bool useMailboxing);
 
-        virtual bool Construct();
+        virtual bool Construct(const ViewCellContainer &viewCells);
 
         /** Check whether subdivision criteria are met for the given subtree.
                 If not subdivide the leafs of the subtree. The criteria are specified in
-                        the environment as well as the subdivision method. By default surface area
+                the environment as well as the subdivision method. By default surface area
                 heuristics is used.
 
@@ -372 +372 @@
                 {}
 
-                bool operator<(const SortableEntry &b) const 
+                /*bool operator<(const SortableEntry &b) const 
                 {
+                        // view cells usually adjacent 
+                        if (EpsilonEqual(value, b.value, 0.001))
+                                return (type == BOX_MAX);
+                        
                         return value < b.value;
-                }
+                }*/
         };
 
         inline static bool iltS(SortableEntry *a, SortableEntry *b)
         {
+                // view cells usually adjacent 
+                //if (EpsilonEqual(a->value, b->value))
+                //      return false;
+                //      return (a->type == SortableEntry::BOX_MAX);
+                        
                 return a->value < b->value;
         }
@@ -409 +418 @@
                                         float &position);
 
+        int FindViewCellIntersections(const Vector3 &lStart, 
+                                                                  const Vector3 &lEnd,
+                                                                  const ViewCellContainer &viewCells,
+                                                                  ViewCellContainer &hitViewCells,
+                                                                  const bool useMailboxing);
 
         ////////////////////////