Changeset 1006 for GTP/trunk/Lib/Vis/Preprocessing/src/VspBspTree.h

Timestamp:

06/09/06 01:26:46 (18 years ago)

Author:

mattausch

Message:

started viewspace-objectspace subdivision
removed memory leaks

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/VspBspTree.h (modified) (8 diffs)

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

@@ -158 +158 @@
         struct VspBspSplitCandidate
         {  
-                /// the current node
+                /// the current split plane
                 Plane3 mSplitPlane;
                 /// split axis of this plane (0, 1, 2, or 3 if non-axis-aligned)
@@ -467 +467 @@
                 @param plane returns the split plane
                 @param leaf the leaf to be split
-                @param polys the polygon list on which the split decition is based
-                @param rays ray container on which selection may be based
+                @param data the traversal data holding the polygons and rays which the split decision is based
+                @param frontData the front node traversal data (which may be updated to avoid repcomputations
+                @param backData the front node traversal data (which may be updated to avoid repcomputations
+                @param splitAxis 0 - 2 if axis aligned split, 3 if polygon-aligned split
+
                 @note the polygons can be reordered in the process
+                
                 @returns true if the cost of the split is under maxCostRatio
 
@@ -567 +571 @@
                                                                   float &position);
 
-        /** Selects an axis aligned split plane.
-                @Returns true if split is valied
-        */
-        bool SelectAxisAlignedPlane(Plane3 &plane, const PolygonContainer &polys) const;
-
         /** Subdivides the rays into front and back rays according to the split plane.
                 
@@ -649 +648 @@
                                   int &contributingSamples);
 
-
-
-
-
         
         /** Take 3 ray endpoints, where two are minimum and one a maximum
@@ -701 +696 @@
         /** Returns estimated memory usage of tree.
         */
+        float GetMemUsage() const;
         //float GetMemUsage(const VspBspTraversalQueue &tstack) const;
-        float GetMemUsage() const;
-
-
-
+
+
+
+        ///////////////////////////////////////////////////////////
+protected:
+        
         /// Pointer to the root of the tree
         BspNode *mRoot;
-                
+        
+        /// the pointer to the view cells manager
+        ViewCellsManager *mViewCellsManager;
+        
+        /// View cell corresponding to the space outside the valid view space
+        BspViewCell *mOutOfBoundsCell;
+
+        /// the bsp tree statistics
         BspTreeStatistics mBspStats;
 
-        /// Strategies for choosing next split plane.
-        enum {NO_STRATEGY = 0,
-                  RANDOM_POLYGON = 1, 
-                  AXIS_ALIGNED = 2,
-                  LEAST_RAY_SPLITS = 256,
-                  BALANCED_RAYS = 512,
-                  PVS = 1024
-                };
+        /// sorted split candidates used for sweep-heuristics
+        vector<SortableEntry> *mSplitCandidates;
 
         /// box around the whole view domain
         AxisAlignedBox3 mBox;
 
-        bool mUseCostHeuristics;
+        
+        //-- termination critera
 
         /// minimal number of rays before subdivision termination
@@ -737 +737 @@
         /// minimal accumulated ray length
         float mTermMinAccRayLength;
-
-        //HACK
-        int mTermMinPolygons;
+        /// maximal acceptable cost ratio
+        float mTermMaxCostRatio;
+        /// tolerance value indicating how often the max cost ratio can be failed
+        int mTermMissTolerance;
+
+
+        //-- termination criteria for
+        //-- hybrid stategy where only axis aligned split are used until 
+        //-- a certain point and then also polygon aligned split are taken
+         
+        /// minimal number of rays where axis aligned split is taken
+        int mTermMinRaysForAxisAligned;
+        /// max ray contribution
+        float mTermMaxRayContriForAxisAligned;
+        /// weight for heuristics evaluation
+        float mAxisAlignedCtDivCi;
+        /// spezifies the split border of the axis aligned split
+        float mAxisAlignedSplitBorder;
+
+
+        //-- global terminatino criteria
 
         float mTermMinGlobalCostRatio;
         int mTermGlobalCostMissTolerance;
-
         int mGlobalCostMisses;
 
-        bool mUseSplitCostQueue;
-        //-- termination criteria for axis aligned split
-
-        /// minimal number of rays for axis aligned split
-        int mTermMinRaysForAxisAligned;
-        // max ray contribution
-        float mTermMaxRayContriForAxisAligned;
-
-        /// strategy to get the best split plane
-        int mSplitPlaneStrategy;
+        /// maximal number of view cells
+        int mMaxViewCells;
+        /// maximal tree memory
+        float mMaxMemory;
+        /// the tree is out of memory
+        bool mOutOfMemory;
+
+
         /// number of candidates evaluated for the next split plane
         int mMaxPolyCandidates;
         /// number of candidates for split planes evaluated using the rays
         int mMaxRayCandidates;
+        
+
+
+        //-- axis aligned split criteria
+
+        /// if only driving axis should be used for choosing the axis-aligned split
+        bool mOnlyDrivingAxis;
+        /// if heuristics should be used to place the split plane of an axis-aligned split
+        bool mUseCostHeuristics;
+        /// if driving axis should taken if max cost is exceeded for
+        /// all evaluated axis aligned split plane candidates
+        bool mUseDrivingAxisIfMaxCostViolated;
+        /// minimal relative position where the split axis can be placed
+        float mMinBand;
+        /// maximal relative position where the split axis can be placed
+        float mMaxBand;
         /// balancing factor for PVS criterium
         float mCtDivCi;
-
-        bool mUseDrivingAxisForMaxCost;
-        //-- axis aligned split criteria
-        float mAxisAlignedCtDivCi;
-        /// spezifies the split border of the axis aligned split
-        float mAxisAlignedSplitBorder;
-
-        /// maximal acceptable cost ratio
-        float mTermMaxCostRatio;
-        /// tolerance value indicating how often the max cost ratio can be failed
-        int mTermMissTolerance;
+        /// if random split axis should be used
+        bool mUseRandomAxis;
+        /// if vsp bsp tree should simulate octree
+        bool mCirculatingAxis;
+
+
+        
+        /// priority queue strategy
+        enum {BREATH_FIRST, DEPTH_FIRST, COST_BASED};
+        /// if we should use breath first priority for the splits
+        int mNodePriorityQueueType;
+        /// if split cost queue should be used to compute next best split
+        bool mUseSplitCostQueue;
+        
+
+        
+        /// Strategies for choosing next split plane.
+        enum {NO_STRATEGY = 0,
+                  RANDOM_POLYGON = 1, 
+                  AXIS_ALIGNED = 2,
+                  LEAST_RAY_SPLITS = 256,
+                  BALANCED_RAYS = 512,
+                  PVS = 1024
+                };
+
+        /// strategy to get the best split plane
+        int mSplitPlaneStrategy;
 
         //-- factors guiding the split plane heuristics
+
         float mLeastRaySplitsFactor;
         float mBalancedRaysFactor;
         float mPvsFactor;
+
 
         /// if area or volume should be used for PVS heuristics
@@ -787 +836 @@
         /// normalizes different bsp split plane criteria
         float mCostNormalizer;
-        /// maximal number of view cells
-        int mMaxViewCells;
-        
-        ofstream  mSubdivisionStats;
-
         // if rays should be stored in leaves
         bool mStoreRays;
-        
-        /// if only driving axis should be used for split
-        bool mOnlyDrivingAxis;
-
-        ViewCellsManager *mViewCellsManager;
-
-        vector<SortableEntry> *mSplitCandidates;
-
-        
+        /// render cost weight between expected value and variance
         float mRenderCostWeight;
-        /// View cell corresponding to the space outside the valid view space
-        BspViewCell *mOutOfBoundsCell;
-
-        /// maximal tree memory
-        float mMaxMemory;
-        /// the tree is out of memory
-        bool mOutOfMemory;
-        
+        
+
+        //-- subdivision statistics
+
+        /// subdivision stats output file
+        ofstream mSubdivisionStats;
         float mTotalCost;
         int mTotalPvsSize;
 
-        float mMinBand;
-        float mMaxBand;
-
-        //int mSplits;
-        /// subdivision stats output file
-        ofstream mSubdivsionStats;
-        /// if random split axis should be used
-        bool mUseRandomAxis;
+
         /// use polygon split whenever there are polys left
         bool mUsePolygonSplitIfAvailable;
@@ -829 +856 @@
         /// number of currenly generated view cells
         int mCreatedViewCells;
-        /// if vsp bsp tree should simulate octree
-        bool mCirculatingAxis;
-
-        /// if we should use breath first priority for the splits
-        int mNodePriorityQueueType;
-
-        bool mEmptyViewCellsMergeAllowed;
-
-        // priority queue strategy
-        enum {BREATH_FIRST, DEPTH_FIRST, COST_BASED};
+
+
 private: