Changeset 418 for trunk/VUT/GtpVisibilityPreprocessor/src/VspKdTree.h

Timestamp:

11/16/05 18:33:18 (19 years ago)

Author:

mattausch

Message:

 

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/VspKdTree.h (modified) (5 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/VspKdTree.h

@@ -272 +272 @@
 {
 public:
-  // plane in local modelling coordinates
-  float position;
-
-  // pointers to children
-  VspKdTreeNode *back, *front;
-
-  // the bbox of the node
-  AxisAlignedBox3 bbox;
-
-  // the bbox of the node
-  AxisAlignedBox3 dirBBox;
-  
-  // data for caching
-  long accesses;
-  long lastAccessTime;
-  
-  VspKdTreeInterior(VspKdTreeInterior *p):VspKdTreeNode(p),
-                                        back(NULL),
-                                        front(NULL),
-                                        accesses(0),
-                                        lastAccessTime(-1)
-  { }
-
-  virtual int GetAccessTime() {
-    return lastAccessTime;
-  }
-
-  void SetupChildLinks(VspKdTreeNode *b, VspKdTreeNode *f) {
-    back = b;
-    front = f;
-    b->parent = f->parent = this;
-  }
-
-  void ReplaceChildLink(VspKdTreeNode *oldChild, VspKdTreeNode *newChild) {
-    if (back == oldChild)
-      back = newChild;
-    else
-      front = newChild;
-  }
-
-  virtual int Type() const  { return EInterior; }
-  
-  virtual ~VspKdTreeInterior()
-  {
-          DEL_PTR(back);
-          DEL_PTR(front);
-  }
-  
-  virtual void Print(ostream &s) const 
-  {
-          if (axis == 0)
-                  s << "x ";
-          else
-                  if (axis == 1)
-                          s << "y ";
-                  else
-                          s << "z ";
-          s << position << " ";
-          back->Print(s);
-          front->Print(s);
-  }
-        
-  int ComputeRayIntersection(const RayInfo &rayData, float &t) 
-  {
-          return rayData.ComputeRayIntersection(axis, position, t);
-  }
-
+        
+        VspKdTreeInterior(VspKdTreeInterior *p);
+                        
+        virtual int GetAccessTime();
+        
+        virtual int Type();
+  
+        virtual ~VspKdTreeInterior();
+    
+        virtual void Print(ostream &s) const;
+
+protected:
+
+        void SetupChildLinks(VspKdTreeNode *b, VspKdTreeNode *f);
+ 
+        void ReplaceChildLink(VspKdTreeNode *oldChild, VspKdTreeNode *newChild);
+ 
+        int ComputeRayIntersection(const RayInfo &rayData, float &t);
+
+        // plane in local modelling coordinates
+        float mPosition;
+
+        // pointers to children
+        VspKdTreeNode *mBack;
+        VspKdTreeNode *mFront;
+
+        // the bbox of the node
+        AxisAlignedBox3 mBbox;
+
+        // data for caching
+        long mAccesses;
+        long mLastAccessTime;
 };
 
@@ -543 +508 @@
         
 public:
-        
-        /////////////////////////////
-        // The core pointer
-        VspKdTreeNode *root;
-  
-        /////////////////////////////
-        // Basic properties
-
-        // total number of nodes of the tree
-        int nodes;
-        
-        // axis aligned bounding box of the scene
-        AxisAlignedBox3 bbox;
-
-        // axis aligned bounding box of directions
-        AxisAlignedBox3 dirBBox;
-
-        const VspKdStatistics &GetStatistics() const {
-                return mStat;
-        }
-        /////////////////////////////
-        // Construction parameters
-
-        // epsilon used for the construction
-        float epsilon;
-
-        // ratio between traversal and intersection costs
-        float ct_div_ci;
-        
-        // max depth of the tree
-        int termMaxDepth;
-        // minimal ratio of the volume of the cell and the query volume
-        float termMinSize;
-
-        // minimal pvs per node to still get subdivided
-        int termMinPvs;
-
-        // minimal ray number per node to still get subdivided
-        int termMinRays;
-        
-        // maximal cost ration to subdivide a node
-        float termMaxCostRatio;
-        
-        // maximal contribution per ray to subdivide the node
-        float termMaxRayContribution;
-
-        // randomized construction
-        bool randomize;
-
-        // type of the splitting to use for the tree construction
-        enum {ESplitRegular, ESplitHeuristic };
-        int splitType;
-        
-        // maximal size of the box on which the refdir splitting can be performed
-        // (relative to the scene bbox
-        float refDirBoxMaxSize;
-  
-        // maximum alovable memory in MB
-        float maxTotalMemory;
-
-        // maximum alovable memory for static kd tree in MB
-        float maxStaticMemory;
-
-        // this is used during the construction depending
-        // on the type of the tree and queries...
-        float maxMemory;
-
-        // minimal acess time for collapse
-        int accessTimeThreshold;
-
-        // minimal depth at which to perform collapse
-        int minCollapseDepth;
-        
-        // reusable array of split candidates
-        vector<SortableEntry> *splitCandidates;
-        
-        /////////////////////////////
-        VspKdStatistics mStat;
-        
+
         VspKdTree();
         virtual ~VspKdTree();
@@ -697 +584 @@
                                                 int &pvsFront);
 
-        AxisAlignedBox3 GetBBox(const VspKdTreeNode *node) 
-        {
-                if (node->parent == NULL)
-                        return bbox;
-
-                if (!node->IsLeaf())
-                        return ((VspKdTreeInterior *)node)->bbox;
-
-                if (node->parent->axis >= 3)
-                        return node->parent->bbox;
-      
-                AxisAlignedBox3 box(node->parent->bbox);
-                if (node->parent->front == node)
-                        box.SetMin(node->parent->axis, node->parent->position);
-                else
-                        box.SetMax(node->parent->axis, node->parent->position);
-                return box;
-        }
-
-        AxisAlignedBox3 GetDirBBox(const VspKdTreeNode *node) 
-        {
-                if (node->parent == NULL)
-                        return dirBBox;
-                if (!node->IsLeaf())
-                        return ((VspKdTreeInterior *)node)->dirBBox;
-                if (node->parent->axis < 3)
-                        return node->parent->dirBBox;
-    
-                AxisAlignedBox3 dBBox(node->parent->dirBBox);
-
-                if (node->parent->front == node)
-                        dBBox.SetMin(node->parent->axis - 3, node->parent->position);
-                else
-                        dBBox.SetMax(node->parent->axis - 3, node->parent->position);
-                return dBBox;
-        }
-  
-        int     ReleaseMemory(const int time);
-
-        int     CollapseSubtree(VspKdTreeNode *node, const int time);
-        
-        void CountAccess(VspKdTreeInterior *node, const long time) 
-        {
-                ++ node->accesses;
-                node->lastAccessTime = time;
-        }
+        AxisAlignedBox3 GetBBox(const VspKdTreeNode *node);     
 
         VspKdTreeNode * SubdivideLeaf(VspKdTreeLeaf *leaf,
@@ -759 +601 @@
 
 
-        int     GetRootPvsSize() const 
-        {
-                return GetPvsSize(root, bbox);
-        }
+        int     GetRootPvsSize() const;
         
         int     GetPvsSize(VspKdTreeNode *node, const AxisAlignedBox3 &box) const;
@@ -774 +613 @@
 
         float GetAvgPvsSize();
+
+        /** Get the root of the tree.
+        */
+        VspKdTreeNode *GetRoot() const;
+
+        int CollapseSubtree(VspKdTreeNode *sroot, const int time);
+
+        const VspKdStatistics &GetStatistics() const {
+                return mStat;
+        }
+        
+        
+        /////////////////////////////
+        // Construction parameters
+
+        // max depth of the tree
+        int sTermMaxDepth;
+
+        // minimal ratio of the volume of the cell and the query volume
+        float sTermMinSize;
+
+        // minimal pvs per node to still get subdivided
+        int sTermMinPvs;
+
+        // minimal ray number per node to still get subdivided
+        int sTermMinRays;
+        
+        // maximal cost ration to subdivide a node
+        float sTermMaxCostRatio;
+        
+        // maximal contribution per ray to subdivide the node
+        float sTermMaxRayContribution;
+
+protected:
+        /////////////////////////////
+        // The core pointer
+        VspKdTreeNode *mRoot;
+  
+        /////////////////////////////
+        // Basic properties
+
+        // total number of nodes of the tree
+        int nodes;
+        
+        // axis aligned bounding box of the scene
+        AxisAlignedBox3 mBox;
+
+        // epsilon used for the construction
+        float epsilon;
+
+        // ratio between traversal and intersection costs
+        float ct_div_ci;
+        
+        // type of the splitting to use for the tree construction
+        enum {ESplitRegular, ESplitHeuristic };
+        int splitType;
+        
+        // maximum alovable memory in MB
+        float maxTotalMemory;
+
+        // maximum alovable memory for static kd tree in MB
+        float maxStaticMemory;
+
+        // this is used during the construction depending
+        // on the type of the tree and queries...
+        float maxMemory;
+
+        // minimal acess time for collapse
+        int accessTimeThreshold;
+
+        // minimal depth at which to perform collapse
+        int minCollapseDepth;
+        
+        // reusable array of split candidates
+        vector<SortableEntry> *splitCandidates;
+        
+        /////////////////////////////
+        VspKdStatistics mStat;  
 };