Changeset 1640

Timestamp:

10/18/06 18:17:27 (18 years ago)

Author:

mattausch

Message:

worked on vsp osp methodsd

Location:

GTP/trunk/Lib/Vis

Files:

• OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp (modified) (1 diff)
• Preprocessing/scripts/vsposp_typical.env (modified) (4 diffs)
• Preprocessing/scripts/vsposp_typical.sh (modified) (4 diffs)
• Preprocessing/src/BvHierarchy.cpp (modified) (6 diffs)
• Preprocessing/src/BvHierarchy.h (modified) (17 diffs)
• Preprocessing/src/Environment.cpp (modified) (3 diffs)
• Preprocessing/src/HierarchyManager.cpp (modified) (35 diffs)
• Preprocessing/src/HierarchyManager.h (modified) (10 diffs)
• Preprocessing/src/ViewCellsManager.cpp (modified) (2 diffs)
• Preprocessing/src/VspTree.cpp (modified) (7 diffs)
• Preprocessing/src/VspTree.h (modified) (4 diffs)
• Preprocessing/src/main.cpp (modified) (1 diff)

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp

@@ -160 +160 @@
 void OcclusionCullingSceneManager::PrepareVisualization(Camera *cam)
 {
-        //Ogre::LogManager::getSingleton().logMessage("here4");
         // add player camera for visualization purpose
         try 

GTP/trunk/Lib/Vis/Preprocessing/scripts/vsposp_typical.env

@@ -184 +184 @@
 VspTree {
         Construction {
-                samples 100000
         }
 
@@ -225 +224 @@
         
         Construction {
-                # type 0 = sequential computation, type 1=interleaved
-                type 2
+
+                samples 100000
+
+                # type 0 = sequential computation, 1 = interleaved, 2 = gradient
+                type 1
+
                 # if the object space should be subdivided first (if false, the view space is subdivided first)
                 startWithObjectSpace true
@@ -233 +236 @@
                 # only for interleaved method
 
-                # only for interleaved method: the minimum depth for object space partition
-                minDepthForOsp 7
-                # the minimum depth for view space partition
-                minDepthForVsp 7
-
                 # if dirty split candidates are reevaluated 
-                repairQueue false
+                repairQueue true
+
+                # recompute split plane when "repairing" a candidate
+                recomputeSplitPlaneOnRepair false
 
                 ###################################################
@@ -249 +250 @@
                 levels 4
 
-                # recompute split plane when "repairing" a candidate
-                recomputeSplitPlaneOnRepair true
+                # minimal steps of same type: for interleaved, this is only valid for the first few splits
+                minStepsOfSameType 200
         }
 

GTP/trunk/Lib/Vis/Preprocessing/scripts/vsposp_typical.sh

@@ -12 +12 @@
 
 SCENE=vsposp_typical
+#SCENE=vsposp_vienna
 #SCENE=soda5
 #SCENE=cube
@@ -25 +26 @@
 
 
-METHOD=sequential
+METHOD=interleaved_full
 echo "$SCENE $METHOD"
 
@@ -34 +35 @@
 -bvh_subdivision_stats=$LOG_PREFIX-$METHOD-bvh-subdivisionStats.log \
 -hierarchy_subdivision_stats=$LOG_PREFIX-$METHOD-hierarchy-subdivisionStats.log \
--hierarchy_construction_start_with_osp=true
+-hierarchy_construction_type=1 \
+-hierarchy_construction_recompute_split_on_repair=true
 
 mv debug.log $LOG_PREFIX-$METHOD-debug.log
@@ -40 +42 @@
 mv final_object_partition.wrl $LOG_PREFIX-$METHOD-final_object_partition.wrl
 mv final_view_cells.wrl $LOG_PREFIX-$METHOD-final_view_cells.wrl
+
+
+METHOD=interleaved
+echo "$SCENE $METHOD"
+
+$PROGRAM $ENVIRONMENT \
+-view_cells_evaluation_stats_prefix=$LOG_PREFIX-$METHOD \
+-view_cells_merge_stats=$LOG_PREFIX-$METHOD-mergeStats.log \
+-vsp_subdivision_stats=$LOG_PREFIX-$METHOD-vsp-subdivisionStats.log \
+-bvh_subdivision_stats=$LOG_PREFIX-$METHOD-bvh-subdivisionStats.log \
+-hierarchy_subdivision_stats=$LOG_PREFIX-$METHOD-hierarchy-subdivisionStats.log \
+-hierarchy_construction_type=1 \
+-hierarchy_construction_recompute_split_on_repair=false
+
+mv debug.log $LOG_PREFIX-$METHOD-debug.log
+mv view_cells.wrl $LOG_PREFIX-$METHOD-view_cells.wrl
+mv final_object_partition.wrl $LOG_PREFIX-$METHOD-final_object_partition.wrl
+mv final_view_cells.wrl $LOG_PREFIX-$METHOD-final_view_cells.wrl
+
+
+METHOD=gradient
+echo "$SCENE $METHOD"
+
+$PROGRAM $ENVIRONMENT \
+-view_cells_evaluation_stats_prefix=$LOG_PREFIX-$METHOD \
+-view_cells_merge_stats=$LOG_PREFIX-$METHOD-mergeStats.log \
+-vsp_subdivision_stats=$LOG_PREFIX-$METHOD-vsp-subdivisionStats.log \
+-bvh_subdivision_stats=$LOG_PREFIX-$METHOD-bvh-subdivisionStats.log \
+-hierarchy_subdivision_stats=$LOG_PREFIX-$METHOD-hierarchy-subdivisionStats.log \
+-hierarchy_construction_type=2 \
+-hierarchy_construction_recompute_split_on_repair=true
+
+mv debug.log $LOG_PREFIX-$METHOD-debug.log
+mv view_cells.wrl $LOG_PREFIX-$METHOD-view_cells.wrl
+mv final_object_partition.wrl $LOG_PREFIX-$METHOD-final_object_partition.wrl
+mv final_view_cells.wrl $LOG_PREFIX-$METHOD-final_view_cells.wrl

GTP/trunk/Lib/Vis/Preprocessing/src/BvHierarchy.cpp

@@ -1501 +1501 @@
                 mHierarchyManager->mVspTree->GetViewCells(*ray, tmpViewCells);
 
+                // matt: probably slow to allocate memory for view cells every time
                 ViewCellContainer::const_iterator vit, vit_end = tmpViewCells.end();
 
@@ -1786 +1787 @@
 
 
-void BvHierarchy::CreateRoot(const ObjectContainer &objects)
+void BvHierarchy::Initialise(const ObjectContainer &objects)
 {
         ///////
@@ -1796 +1797 @@
         mRoot = bvhleaf;
 
+        // compute bounding box from objects
+        mBoundingBox = mRoot->GetBoundingBox();
+
         // associate root with current objects
         AssociateObjectsWithLeaf(bvhleaf);
 }
+
 
 /*
@@ -1831 +1836 @@
         BvhSubdivisionCandidate::sBvHierarchy = this;
         
-        // create new root
-        CreateRoot(objects);
-
-        // compute bounding box from objects
-        mBoundingBox = mRoot->GetBoundingBox();
+        // root and bounding box was already constructed
         BvhLeaf *bvhLeaf = dynamic_cast<BvhLeaf *>(mRoot);
 
@@ -1961 +1962 @@
         // reset root
         DEL_PTR(mRoot);
-        CreateRoot(objects);
+        
+        BvhLeaf *bvhleaf = new BvhLeaf(mBoundingBox, NULL, (int)objects.size());
+        bvhleaf->mObjects = objects;
+        mRoot = bvhleaf;
         
 #if PROBABILIY_IS_BV_VOLUME
@@ -2072 +2076 @@
 
 
-}
+// TODO: return memory usage in MB
+float BvHierarchy::GetMemUsage() const
+{
+        return (float)
+                 (sizeof(BvHierarchy)
+                  + mBvhStats.Leaves() * sizeof(BvhLeaf) 
+                  + mBvhStats.Interior() * sizeof(BvhInterior)
+                  ) / (1024.0f * 1024.0f);
+}
+
+
+}

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

@@ -544 +544 @@
         BvhIntersectable *GetOrCreateBvhIntersectable(BvhNode *node);
 
-        /** Collects rays.
+        /** Collects rays associated with the objects.
         */
         void CollectRays(const ObjectContainer &objects, VssRayContainer &rays) const;
@@ -551 +551 @@
                 @returns number of view cells found
         */
-        int ComputeBoxIntersections(
-                const AxisAlignedBox3 &box, 
-                ViewCellContainer &viewCells) const;
+        int ComputeBoxIntersections(const AxisAlignedBox3 &box, 
+                                                                ViewCellContainer &viewCells) const;
 
         /** Returns leaf the point pt lies in, starting from root.
@@ -566 +565 @@
         void SetViewCellsTree(ViewCellsTree *vt) { mViewCellsTree = vt; }
 
+        /** Returns estimated memory usage of tree.
+        */
+        float GetMemUsage() const;
 
 protected:
@@ -598 +600 @@
         /** Evaluate balanced object partition.
         */
-        float EvalLocalObjectPartition(
-                const BvhTraversalData &tData,
-                const int axis,
-                ObjectContainer &objectsFront,
-                ObjectContainer &objectsBack);
-
-        float EvalSah(
-                const BvhTraversalData &tData,
-                const int axis,
-                ObjectContainer &objectsFront,
-                ObjectContainer &objectsBack);
+        float EvalLocalObjectPartition(const BvhTraversalData &tData,
+                                                                   const int axis,
+                                                                   ObjectContainer &objectsFront,
+                                                                   ObjectContainer &objectsBack);
+
+        /** Evaluate surface area heuristic for the node.
+        */
+        float EvalSah(const BvhTraversalData &tData,
+                                  const int axis,
+                                  ObjectContainer &objectsFront,
+                                  ObjectContainer &objectsBack);
 
         /** Computes priority of the traversal data and stores it in tData.
@@ -628 +630 @@
                 @returns new root of the subtree
         */
-        BvhNode *Subdivide(
-                SplitQueue &tQueue, 
-                SubdivisionCandidate *splitCandidate,
-                const bool globalCriteriaMet);
+        BvhNode *Subdivide(SplitQueue &tQueue, 
+                                           SubdivisionCandidate *splitCandidate,
+                                           const bool globalCriteriaMet);
         
         /** Subdivides leaf.
@@ -641 +642 @@
                 @returns the new interior node = the of the subdivision
         */
-        BvhInterior *SubdivideNode(
-                const BvhSubdivisionCandidate &sc,
-                BvhTraversalData &frontData,
-                BvhTraversalData &backData);
+        BvhInterior *SubdivideNode(const BvhSubdivisionCandidate &sc,
+                                                           BvhTraversalData &frontData,
+                                                           BvhTraversalData &backData);
 
         /** Splits the objects for the next subdivision.
                 @returns cost for this split
         */
-        float SelectObjectPartition(
-                const BvhTraversalData &tData,
-                ObjectContainer &frontObjects,
-                ObjectContainer &backObjects);
+        float SelectObjectPartition(const BvhTraversalData &tData,
+                                                                ObjectContainer &frontObjects,
+                                                                ObjectContainer &backObjects);
         
         /** Writes the node to disk
@@ -659 +658 @@
         void ExportNode(BvhNode *node, OUT_STREAM &stream);
 
+        /** Exports objects associated with this leaf.
+        */
         void ExportObjects(BvhLeaf *leaf, OUT_STREAM &stream);
-
-        /** Returns estimated memory usage of tree.
-        */
-        float GetMemUsage() const;
 
         /** Associates the objects with their bvh leaves.
@@ -677 +674 @@
                 @param axis the current split axis
         */
-        void PrepareLocalSubdivisionCandidates(
-                const BvhTraversalData &tData,
-                const int axis);
-
-        static void CreateLocalSubdivisionCandidates(
-                const ObjectContainer &objects, 
-                SortableEntryContainer **subdivisionCandidates,
-                const bool sort,
-                const int axis);
+        void PrepareLocalSubdivisionCandidates(const BvhTraversalData &tData,
+                                                                                   const int axis);
+
+        static void CreateLocalSubdivisionCandidates(const ObjectContainer &objects, 
+                                                                                                 SortableEntryContainer **subdivisionCandidates,
+                                                                                                 const bool sort,
+                                                                                                 const int axis);
 
         /** Computes object partition with the best cost according to the heurisics.
@@ -696 +691 @@
                 @returns relative cost (relative to parent cost)
         */
-        float EvalLocalCostHeuristics(
-                const BvhTraversalData &tData,
-                const int axis,
-                ObjectContainer &objectsFront,
-                ObjectContainer &objectsBack);
+        float EvalLocalCostHeuristics(const BvhTraversalData &tData,
+                                                                  const int axis,
+                                                                  ObjectContainer &objectsFront,
+                                                                  ObjectContainer &objectsBack);
 
         /** Evaluates the contribution to the front and back volume
@@ -709 +703 @@
                 @param volPvs updates the right pvs
         */
-        void EvalHeuristicsContribution(
-                Intersectable *obj,
-                float &volLeft, 
-                float &volRight);
+        void EvalHeuristicsContribution(Intersectable *obj,
+                                                                        float &volLeft, 
+                                                                        float &volRight);
 
         /** Prepares objects for the cost heuristics.
@@ -729 +722 @@
         /** Prepares construction for vsp and osp trees.
         */
-        AxisAlignedBox3 EvalBoundingBox(
-                const ObjectContainer &objects, 
-                const AxisAlignedBox3 *parentBox = NULL) const;
+        AxisAlignedBox3 EvalBoundingBox(const ObjectContainer &objects, 
+                                                                        const AxisAlignedBox3 *parentBox = NULL) const;
 
         /** Collects list of invalid candidates. Candidates
@@ -737 +729 @@
                 that affects this candidate.
         */
-        void CollectDirtyCandidates(
-                BvhSubdivisionCandidate *sc,
-                vector<SubdivisionCandidate *> &dirtyList,
-                const bool onlyUnmailed);
+        void CollectDirtyCandidates(BvhSubdivisionCandidate *sc,
+                                                                vector<SubdivisionCandidate *> &dirtyList,
+                                                                const bool onlyUnmailed);
 
         /** Collect view cells which see this bvh leaf.
         */
-        void CollectViewCells(
-                const ObjectContainer &objects, 
-                ViewCellContainer &viewCells,
-                const bool setCounter = false) const;
+        void CollectViewCells(const ObjectContainer &objects, 
+                                                  ViewCellContainer &viewCells,
+                                                  const bool setCounter = false) const;
 
         /** Counts the view cells of this object. note: only
@@ -760 +750 @@
         /** Collects view cells which see an object.
         */
-        void CollectViewCells(
-                Intersectable *object, 
-                ViewCellContainer &viewCells, 
-                const bool useMailBoxing,
-                const bool setCounter = false) const;
+        void CollectViewCells(Intersectable *object, 
+                                                  ViewCellContainer &viewCells, 
+                                                  const bool useMailBoxing,
+                                                  const bool setCounter = false) const;
 
         /** Evaluates increase in pvs size.
@@ -772 +761 @@
         /** Rays will be clipped to the bounding box.
         */
-        void PreprocessRays(
-                BvhLeaf *root, 
-                const VssRayContainer &sampleRays,
-                RayInfoContainer &rays);
+        void PreprocessRays(BvhLeaf *root, 
+                                                const VssRayContainer &sampleRays,
+                                                RayInfoContainer &rays);
 
         /** Print the subdivision stats in the subdivison log.
@@ -783 +771 @@
         /** Prints out the stats for this subdivision.
         */
-        void AddSubdivisionStats(
-                const int viewCells,
-                const float renderCostDecr,
-                const float totalRenderCost);
+        void AddSubdivisionStats(const int viewCells,
+                                                         const float renderCostDecr,
+                                                         const float totalRenderCost);
 
         /** Stores rays with objects that see the rays.
@@ -800 +787 @@
                 the first subdivision candidate.
         */
-        SubdivisionCandidate *PrepareConstruction(
-                const VssRayContainer &sampleRays,
-                const ObjectContainer &objects);
+        SubdivisionCandidate *PrepareConstruction(const VssRayContainer &sampleRays,
+                                                                                          const ObjectContainer &objects);
 
         /** Resets bv hierarchy. E.g. deletes root and resets stats.
         */
-        SubdivisionCandidate *Reset(
-                const VssRayContainer &rays, 
-                const ObjectContainer &objects);
+        SubdivisionCandidate *Reset(const VssRayContainer &rays, 
+                                                                const ObjectContainer &objects);
 
         /** Evaluates volume of view cells that see the objects.
@@ -820 +805 @@
         /** Assigns sorted objects to front and back data.
         */
-        void AssignSortedObjects(
-                const BvhSubdivisionCandidate &sc,
-                BvhTraversalData &frontData,
-                BvhTraversalData &backData);
-        
-        /** Creates new root of hierarchy.
-        */
-        void CreateRoot(const ObjectContainer &objects);
-/*void
-RenderBvhNode(BvhNode *node)
-{
-  if (node->IsLeaf()) {
-        BvhLeaf *leaf = (BvhLeaf *) node;
-        for (int i=0; i < mObjects.size(); i++)
-                cout << "leaf obj " << i << endl;
-          //RenderIntersectable(mObjects[i]);
-  } else {
-        BvhInterior *in = (BvhInterior *)node;
-        RenderBvhNode(in->GetBack());
-        RenderBvhNode(in->GetFront());
-  }
-  
-}*/
+        void AssignSortedObjects(const BvhSubdivisionCandidate &sc,
+                                                         BvhTraversalData &frontData,
+                                                         BvhTraversalData &backData);
+        
+        /** Creates new root of hierarchy and computes bounding box.
+                Has to be called before the preparation of the subdivision.
+        */
+        void Initialise(const ObjectContainer &objects);
+
+
 protected:
         

GTP/trunk/Lib/Vis/Preprocessing/src/Environment.cpp

@@ -2168 +2168 @@
                                         "10000");
 
-        
         RegisterOption("VspTree.Construction.renderCostDecreaseWeight",
                                 optFloat,
@@ -2462 +2461 @@
 
         
+
         /*******************************************************************/
         /*               Hierarchy Manager related options                 */
         /*******************************************************************/
+
+        RegisterOption("Hierarchy.Construction.samples",
+                                        optInt,
+                                        "vsp_construction_samples=",
+                                        "100000");
+
 
         RegisterOption("Hierarchy.subdivisionStats",
@@ -2525 +2531 @@
                                         "hierarchy_construction_levels=",
                                         "4");
-
-        
+        
+        RegisterOption("Hierarchy.Construction.minStepsOfSameType",
+                                        optInt,
+                                        "hierarchy_construction_min_steps_same_type=",
+                                        "200");
+
         RegisterOption("Hierarchy.Construction.recomputeSplitPlaneOnRepair",
                                         optBool,

GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.cpp

@@ -109 +109 @@
                 "Hierarchy.Construction.levels", mNumMultiLevels);
 
+        Environment::GetSingleton()->GetIntValue(
+                "Hierarchy.Construction.minStepsOfSameType", mMinStepsOfSameType);
+        
+
         char subdivisionStatsLog[100];
         Environment::GetSingleton()->GetStringValue("Hierarchy.subdivisionStats", subdivisionStatsLog);
@@ -116 +120 @@
                 "Hierarchy.Construction.recomputeSplitPlaneOnRepair", mRecomputeSplitPlaneOnRepair);
 
-        Debug << "******** Hierachy Manager Parameters ***********" << endl;
+        Debug << "******** Hierachy Manager Options ***********" << endl;
         Debug << "max leaves: " << mTermMaxLeaves << endl;
         Debug << "min global cost ratio: " << mTermMinGlobalCostRatio << endl;
@@ -124 +128 @@
         Debug << "number of multilevels: " << mNumMultiLevels << endl;
         Debug << "recompute split plane on repair: " << mRecomputeSplitPlaneOnRepair << endl;
+        Debug << "minimal number of steps from same type: " << mMinStepsOfSameType << endl;
 
         switch (mConstructionType)
@@ -228 +233 @@
 void HierarchyManager::EvalSubdivisionStats()
 {
+        // TODO
+        const float objectSpaceMem = GetObjectSpaceMemUsage();
+        const float viewSpaceMem = mVspTree->GetMemUsage();
+        
+        // calculate cost in MB
+        const float memoryCost = mHierarchyStats.mMemory  / (1024.0f * 1024.0f)
+                                                         + objectSpaceMem + viewSpaceMem;
+
         //cout << "pvs entries " << mHierarchyStats.pvsEntries << endl;
         AddSubdivisionStats(mHierarchyStats.Leaves(),
@@ -233 +246 @@
                                                 mHierarchyStats.mTotalCost,
                                                 mHierarchyStats.mPvsEntries,
-                                                mHierarchyStats.mMemory,
-                                                1.0f / (mHierarchyStats.mTotalCost * mHierarchyStats.mMemory)
+                                                memoryCost,
+                                                1.0f / (mHierarchyStats.mTotalCost * memoryCost)
                                                 );
 }
@@ -243 +256 @@
                                                                                    const float totalRenderCost,
                                                                                    const int pvsEntries,
-                                                                                   const int memory,
+                                                                                   const float memory,
                                                                                    const float renderCostPerStorage)
 {
@@ -309 +322 @@
         
         mHierarchyStats.mNodes = 2;
-        
+
+        // create first nodes
+        mVspTree->Initialise(sampleRays, forcedViewSpace);
+        InitialiseObjectSpaceSubdivision(objects);
+
+        // hack: assume that object space can be seen from view space
         mHierarchyStats.mTotalCost = (float)objects.size();
+        mHierarchyStats.mPvsEntries = 1;
+        mHierarchyStats.mMemory = sizeof(PvsData) + sizeof(Intersectable *) / (1024.0f * 1024.0f);
+
+        EvalSubdivisionStats();
         Debug << "setting total cost to " << mHierarchyStats.mTotalCost << endl;
 
@@ -316 +338 @@
         cout << "Constructing view space / object space tree ... \n";
         
-        // compute view space bounding box
-        mVspTree->ComputeBoundingBox(sampleRays, forcedViewSpace);
-
         SplitQueue objectSpaceQueue;
         SplitQueue viewSpaceQueue;
@@ -326 +345 @@
         mSavedViewSpaceSubdivisionType = mViewSpaceSubdivisionType;
         mViewSpaceSubdivisionType = NO_VIEWSPACE_SUBDIV;
-
-        mSavedObjectSpaceSubdivisionType = mObjectSpaceSubdivisionType;
+        //mSavedObjectSpaceSubdivisionType = mObjectSpaceSubdivisionType;
 
         // number of initial splits
-        int minSteps = 200;
+        const int minSteps = mMinStepsOfSameType;
         float renderCostDecr = Limits::Infinity;
 
@@ -337 +355 @@
         
         objectSpaceQueue.Push(osc);
+
 
         /////////////////////////
@@ -349 +368 @@
                 RunConstruction(objectSpaceQueue, dirtyVspList, renderCostDecr, minSteps);
 
-        cout << ospSteps << " object space partition steps taken" << endl;
-
+        cout << "\n" << ospSteps << " object space partition steps taken" << endl;
+
+        // create view space
         SubdivisionCandidate *vsc = 
                         PrepareViewSpaceSubdivision(sampleRays, objects);
 
         viewSpaceQueue.Push(vsc);
-
+        
         // view space subdivision was constructed
         mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
 
-        // don't terminate on max steps
-        //maxSteps = mTermMaxLeaves;
+        // the priorities were calculated for driving sha.
+        // => recalculate "real" priorities taking visibility into
+        // account so we can compare to view space splits
+        ResetQueue(objectSpaceQueue, false);
+
+        
+        // lower number of minsteps: the decicion of which domain to subdivide
+        // should be decided using the render cost decrease from now
+        //minSteps = 1;
 
         // This method subdivides view space / object space 
@@ -370 +397 @@
         while (!(viewSpaceQueue.Empty() && objectSpaceQueue.Empty()))
         {
+                const float vspPriority = viewSpaceQueue.Empty() ? 0 : viewSpaceQueue.Top()->GetPriority();
+                const float ospPriority = objectSpaceQueue.Empty() ? 0 : objectSpaceQueue.Top()->GetPriority();
+
+                cout << "new decicion, vsp: " << vspPriority << ", osp: " << ospPriority << endl;
+
                 // should view or object space be subdivided further?
-                if (viewSpaceQueue.Empty() ||
-                        (!objectSpaceQueue.Empty() &&
-                        (objectSpaceQueue.Top()->GetPriority() > viewSpaceQueue.Top()->GetPriority())))
-                {
-                        // use splits of one kind until rendercost slope is reached
-                        //renderCostDecr = mHierarchyStats.mRenderCostDecrease;
-                        
-                        // lower number of minsteps: this should be solved 
-                        // with render cost decrease from now
-                        //minSteps = 5; 
-
+                if (ospPriority >= vspPriority)
+                {
+                        // use splits of one kind until rendercost decrease of other domain is reached
+                        renderCostDecr = vspPriority;
+                        cout << "comparing with this render cost: " << renderCostDecr << endl;
                         // dirtied view space candidates
                         SubdivisionCandidateContainer dirtyVspList;
@@ -391 +417 @@
                                 RunConstruction(objectSpaceQueue, dirtyVspList, renderCostDecr, minSteps);
 
-                        cout << ospSteps << " object space partition steps taken" << endl;
+                        cout << "\n" << ospSteps << " object space partition steps taken" << endl;
                 
-                        // object space subdivision constructed
-                        mObjectSpaceSubdivisionType = mSavedObjectSpaceSubdivisionType;
-
-                        /// Repair split queue
+                        /// Repair split queue, i.e., affected view space candidates
                         cout << "repairing queue ... " << endl;
                         RepairQueue(dirtyVspList, viewSpaceQueue, true);
-                        cout << "repaired " << dirtyVspList.size() << " candidates" << endl;
+                        cout << "\nrepaired " << (int)dirtyVspList.size() << " candidates" << endl;
                 }
                 else
                 {
                         // use splits of one kind until rendercost slope is reached
-                //      renderCostDecr = mHierarchyStats.mRenderCostDecrease;
+                        renderCostDecr = ospPriority;
+                        cout << "comparing with this render cost: " << renderCostDecr << endl;
 
                         /////////////////
@@ -415 +439 @@
                                 RunConstruction(viewSpaceQueue, dirtyOspList, renderCostDecr, minSteps);
 
-                        cout << vspSteps << " view space partition steps taken" << endl;
+                        cout << "\n" << vspSteps << " view space partition steps taken" << endl;
 
                         // view space subdivision constructed
@@ -423 +447 @@
                         cout << "repairing queue ... " << endl;
                         RepairQueue(dirtyOspList, objectSpaceQueue, true);
-                        cout << "repaired " << dirtyOspList.size() << " candidates" << endl;
+                        cout << "repaired " << (int)dirtyOspList.size() << " candidates" << endl;
                 }
         }
@@ -443 +467 @@
         mHierarchyStats.Start();
         mHierarchyStats.mNodes = 2; // two nodes for view space and object space
-
+        mHierarchyStats.mPvsEntries = 1;
+        mHierarchyStats.mMemory = sizeof(PvsData) + sizeof(Intersectable *) / (1024.0f * 1024.0f);
         mHierarchyStats.mTotalCost = (float)objects.size();
+
         mHierarchyStats.mRenderCostDecrease = 0;
 
@@ -453 +479 @@
         cout << "Constructing view space / object space tree ... \n";
         
-        // compute view space bounding box
-        mVspTree->ComputeBoundingBox(sampleRays, forcedViewSpace);
+        // create only roots
+        mVspTree->Initialise(sampleRays, forcedViewSpace);
+        InitialiseObjectSpaceSubdivision(objects);
 
         // use objects for evaluating vsp tree construction in the 
@@ -464 +491 @@
         mViewSpaceSubdivisionType = NO_VIEWSPACE_SUBDIV;
 
-        // create just one view cell
-        SubdivisionCandidate *vspSc = 
-                PrepareViewSpaceSubdivision(sampleRays, objects);
-
         // start view space subdivison immediately?
         if (StartViewSpaceSubdivision())
         {
                 // prepare vsp tree for traversal
-                mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
+        mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
+                SubdivisionCandidate *vspSc = 
+                        PrepareViewSpaceSubdivision(sampleRays, objects);
+
                 mTQueue.Push(vspSc);
         }
@@ -489 +515 @@
                                         sampleRays, 
                                         objects, 
-                                        forcedViewSpace,// 
-                                        vspSc);
+                                        forcedViewSpace);
         
         cout << "\nfinished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
@@ -519 +544 @@
 
         return vsc;
+}
+
+
+float HierarchyManager::GetObjectSpaceMemUsage() const
+{
+        if (mObjectSpaceSubdivisionType == KD_BASED_OBJ_SUBDIV)
+        {
+                // TODO;
+        }
+        else if (mObjectSpaceSubdivisionType == BV_BASED_OBJ_SUBDIV)
+        {
+                return mBvHierarchy->GetMemUsage();
+        }
+
+        return -1;
+}
+
+void HierarchyManager::InitialiseObjectSpaceSubdivision(const ObjectContainer &objects)
+{
+        if (mObjectSpaceSubdivisionType == KD_BASED_OBJ_SUBDIV)
+        {
+                // TODO;
+        }
+        else if (mObjectSpaceSubdivisionType == BV_BASED_OBJ_SUBDIV)
+        {
+                mBvHierarchy->Initialise(objects);
+        }
 }
 
@@ -608 +660 @@
         }
         
-        mHierarchyStats.mTotalCost -= sc->GetRenderCostDecrease();
-        
         cout << sc->Type() << " ";
                 
+        /////////////
         // update stats
+
         mHierarchyStats.mNodes += 2;
-        
-        const int pvsEntries = sc->GetPvsEntriesIncr();
-        mHierarchyStats.mPvsEntries += pvsEntries;
-        
-        //cout << "pvs entries: " << pvsEntries << " " << mHierarchyStats.pvsEntries << endl;
-        mHierarchyStats.mMemory += 0; // TODO
+        mHierarchyStats.mTotalCost -= sc->GetRenderCostDecrease();
+
+        const int pvsEntriesIncr = sc->GetPvsEntriesIncr();
+        mHierarchyStats.mPvsEntries += pvsEntriesIncr;
+        //cout << "pvs entries: " << pvsEntriesIncr << " " << mHierarchyStats.pvsEntries << endl;
+
+        const int sizeOfEntry = sizeof(PvsData) + sizeof(Intersectable *);
+        // memory size in byte
+        mHierarchyStats.mMemory += float(pvsEntriesIncr * sizeOfEntry);
         mHierarchyStats.mRenderCostDecrease = sc->GetRenderCostDecrease();
 
-        // subdivision successful
+        // output stats
         EvalSubdivisionStats();
                 
@@ -656 +711 @@
 
 
+int HierarchyManager::GetObjectSpaceSubdivisionLeaves() const
+{
+        int maxLeaves= 0;
+
+        if (mObjectSpaceSubdivisionType == KD_BASED_OBJ_SUBDIV)
+        {
+                maxLeaves = mOspTree->mOspStats.Leaves();
+        }
+        else if (mObjectSpaceSubdivisionType == BV_BASED_OBJ_SUBDIV)
+        {
+                maxLeaves = mBvHierarchy->mBvhStats.Leaves();
+        }
+
+        return maxLeaves;
+}
+
+
 bool HierarchyManager::StartObjectSpaceSubdivision() const
 {
@@ -673 +745 @@
         return 
                 ((mConstructionType == INTERLEAVED) && 
-                 (mMinDepthForObjectSpaceSubdivion <= mVspTree->mVspStats.maxDepth));
+                 (mMinStepsOfSameType <= mVspTree->mVspStats.nodes));
 }
 
@@ -694 +766 @@
         return 
                 ((mConstructionType == INTERLEAVED) && 
-                 (mMinDepthForViewSpaceSubdivion <= GetObjectSpaceSubdivisionDepth()));
+                 (mMinStepsOfSameType <= GetObjectSpaceSubdivisionLeaves()));
 }
 
@@ -701 +773 @@
                                                                            const VssRayContainer &sampleRays,
                                                                            const ObjectContainer &objects,
-                                                                           AxisAlignedBox3 *forcedViewSpace,
-                                                                           SubdivisionCandidate *firstVsp)
+                                                                           AxisAlignedBox3 *forcedViewSpace)
 {
         while (!FinishedConstruction())
@@ -719 +790 @@
                         mObjectSpaceSubdivisionType = mSavedObjectSpaceSubdivisionType;
 
-                        cout << "\nstarting object space subdivision at depth " 
-                                 << mVspTree->mVspStats.maxDepth << " (" 
-                                 << mMinDepthForObjectSpaceSubdivion << ") " << endl;
+                        cout << "\nstarting object space subdivision after " 
+                                 << mVspTree->mVspStats.nodes << " (" 
+                                 << mMinStepsOfSameType << ") " << endl;
 
                         SubdivisionCandidate *ospSc = PrepareObjectSpaceSubdivision(sampleRays, objects);
+                        
+                        cout << "reseting queue ... ";
+                        ResetQueue(mTQueue, mRecomputeSplitPlaneOnRepair);
+                        cout << "finished" << endl;
+
                         mTQueue.Push(ospSc);
+                }
+
+                if (StartViewSpaceSubdivision())
+                {
+                        mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
+
+                        cout << "\nstarting view space subdivision at depth " 
+                                 << GetObjectSpaceSubdivisionLeaves() << " (" 
+                                 << mMinStepsOfSameType << ") " << endl;
+
+                        SubdivisionCandidate *vspSc = PrepareViewSpaceSubdivision(sampleRays, objects);
 
                         cout << "reseting queue ... ";
-                        ResetQueue();
+                        ResetQueue(mTQueue, mRecomputeSplitPlaneOnRepair);
                         cout << "finished" << endl;
-                }
-
-                if (StartViewSpaceSubdivision())
-                {
-                        mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
-
-                        cout << "\nstarting view space subdivision at depth " 
-                                 << GetObjectSpaceSubdivisionDepth() << " (" 
-                                 << mMinDepthForViewSpaceSubdivion << ") " << endl;
-
-                        //SubdivisionCandidate *vspSc = PrepareViewSpaceSubdivision(sampleRays, objects);
-                        mTQueue.Push(firstVsp);
-
-                        cout << "reseting queue ... ";
-                        ResetQueue();
-                        cout << "finished" << endl;
+
+                        // push view space candidate                    
+                        mTQueue.Push(vspSc);
                 }
 
@@ -784 +858 @@
                 if ((sc->GetRenderCostDecrease() < minRenderCostDecr) &&
                         !(steps < minSteps))
+                {
+                        cout << "breaking on " << sc->GetRenderCostDecrease() << " smaller than " << minRenderCostDecr << endl;
                         break;
-
+                }
                 ////////
                 //-- subdivide leaf node of either type
@@ -826 +902 @@
                 
                         mHierarchyStats.mTotalCost = mBvHierarchy->mTotalCost;
-
+                        
+                        // bug!! pvs entries could be much higher at this stage
                         mHierarchyStats.mNodes = 2;
-                        mHierarchyStats.mPvsEntries = 0;
+                        mHierarchyStats.mPvsEntries = 1;
                         mHierarchyStats.mRenderCostDecrease = 0;
 
@@ -861 +938 @@
         
         mHierarchyStats.mNodes = 2;
-        mHierarchyStats.mPvsEntries = 0;
+        // bug!! pvs entries could be much higher at this stage
+        mHierarchyStats.mPvsEntries = 1;
         mHierarchyStats.mRenderCostDecrease = 0;
 
+        // evaluate new stats before first subdivsiion
         EvalSubdivisionStats();
 
@@ -884 +963 @@
         cout << "Constructing view space / object space tree ... \n";
         
-        // compute view space bounding box
-        mVspTree->ComputeBoundingBox(sampleRays, forcedViewSpace);
+        // initialise view / object space
+        mVspTree->Initialise(sampleRays, forcedViewSpace);
+        InitialiseObjectSpaceSubdivision(objects);
 
         // use sah for evaluating osp tree construction 
@@ -892 +972 @@
         mSavedViewSpaceSubdivisionType = mViewSpaceSubdivisionType;
         mViewSpaceSubdivisionType = NO_VIEWSPACE_SUBDIV;
-        
-        // first view cell
-        SubdivisionCandidate *vspVc = PrepareViewSpaceSubdivision(sampleRays, objects);
 
         mSavedObjectSpaceSubdivisionType = mObjectSpaceSubdivisionType;
-        //mObjectSpaceSubdivisionType = NO_OBJ_SUBDIV;
+        mObjectSpaceSubdivisionType = NO_OBJ_SUBDIV;
 
         const int limit = mNumMultiLevels;
@@ -935 +1012 @@
                 // subdivide view space with respect to the objects
 
-                if (!ViewSpaceSubdivisionConstructed())
-                {
-                        mTQueue.Push(vspVc);
-                        
-                        // view space subdivision constructed
-                        mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
-                }
-                else
-                {
-                        ResetViewSpaceSubdivision(sampleRays, objects);
-                }
+                SubdivisionCandidate *vspVc = ResetViewSpaceSubdivision(sampleRays, objects);
+                mTQueue.Push(vspVc);
+
+                // view space subdivision constructed
+                mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
+                
 
                 // process view space candidates
@@ -969 +1041 @@
         FinishObjectSpaceSubdivision(objects);
 }
+
+
+void HierarchyManager::OptimizeMultiLevel(const VssRayContainer &sampleRays,                                                                                     
+                                                                                  const ObjectContainer &objects,
+                                                                                  AxisAlignedBox3 *forcedViewSpace)
+{
+        mHierarchyStats.Reset();
+        mHierarchyStats.Start();
+        mHierarchyStats.mNodes = 2;
+        
+        mHierarchyStats.mTotalCost = (float)objects.size();
+        Debug << "setting total cost to " << mHierarchyStats.mTotalCost << endl;
+
+        const long startTime = GetTime();
+        cout << "Constructing view space / object space tree ... \n";
+        
+        // initialise view / object space
+        mVspTree->Initialise(sampleRays, forcedViewSpace);
+        InitialiseObjectSpaceSubdivision(objects);
+
+        // use sah for evaluating osp tree construction 
+        // in the first iteration of the subdivision
+        
+        mSavedViewSpaceSubdivisionType = mViewSpaceSubdivisionType;
+        mViewSpaceSubdivisionType = NO_VIEWSPACE_SUBDIV;
+
+        mSavedObjectSpaceSubdivisionType = mObjectSpaceSubdivisionType;
+        mObjectSpaceSubdivisionType = NO_OBJ_SUBDIV;
+
+        const int limit = mNumMultiLevels;
+        int i = 0;
+
+        // This method subdivides view space / object space 
+        // in order to converge to some optimal cost for this partition
+        // start with object space partiton
+        // then optimizate view space partition for the current osp
+        // and vice versa until iteration depth is reached.
+        while (1)
+        {
+                char subdivisionStatsLog[100];
+                sprintf(subdivisionStatsLog, "tests/i3d/subdivision-%04d.log", i);
+                mSubdivisionStats.open(subdivisionStatsLog);
+
+                // subdivide object space first
+                ResetObjectSpaceSubdivision(sampleRays, objects);
+
+                // process object space candidates
+                RunConstruction(false);
+
+                // object space subdivision constructed
+                mObjectSpaceSubdivisionType = mSavedObjectSpaceSubdivisionType;
+
+                cout << "iteration " << i << " of " << limit << " finished" << endl;
+
+                mSubdivisionStats.close();
+
+                if ((i ++) >= limit)
+                        break;
+
+                sprintf(subdivisionStatsLog, "tests/i3d/subdivision-%04d.log", i);
+                mSubdivisionStats.open(subdivisionStatsLog);
+
+                /////////////////
+                // subdivide view space with respect to the objects
+
+                SubdivisionCandidate *vspVc = ResetViewSpaceSubdivision(sampleRays, objects);
+                mTQueue.Push(vspVc);
+
+                // view space subdivision constructed
+                mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
+                
+
+                // process view space candidates
+                RunConstruction(false);
+
+                cout << "iteration " << i << " of " << limit << " finished" << endl;
+
+                mSubdivisionStats.close();
+
+                if ((i ++) >= limit)
+                        break;
+        }
+        
+        cout << "\nfinished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+
+/*#if _DEBUG
+        cout << "view space: " << GetViewSpaceBox() << endl;
+        cout << "object space:  " << GetObjectSpaceBox() << endl;
+#endif*/
+
+        mHierarchyStats.Stop();
+        mVspTree->mVspStats.Stop();
+        FinishObjectSpaceSubdivision(objects);
+}
+
 
 
@@ -1067 +1234 @@
 
 
-void HierarchyManager::ResetQueue()
+void HierarchyManager::ResetQueue(SplitQueue &splitQueue, const bool recomputeSplitPlane)
 {
         SubdivisionCandidateContainer mCandidateBuffer;
 
         // remove from queue
-        while (!mTQueue.Empty())
-        {
-                SubdivisionCandidate *candidate = NextSubdivisionCandidate(mTQueue);
+        while (!splitQueue.Empty())
+        {
+                SubdivisionCandidate *candidate = NextSubdivisionCandidate(splitQueue);
                  // reevaluate local split plane and priority
-                candidate->EvalPriority();
+                candidate->EvalPriority(recomputeSplitPlane);
                 cout << ".";
                 mCandidateBuffer.push_back(candidate);
@@ -1085 +1252 @@
     for (sit = mCandidateBuffer.begin(); sit != sit_end; ++ sit)
         {
-                mTQueue.Push(*sit);
+                splitQueue.Push(*sit);
         }
 }

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

@@ -51 +51 @@
         /// total number of entries in the pvs
         int mPvsEntries;
-        /// storage cost
-        int mMemory;
+        /// storage cost in MB
+        float mMemory;
         /// total number of nodes
         int mNodes;
@@ -76 +76 @@
 
         int Nodes() const {return mNodes;}
-        int Interior() const { return mNodes / 2; }
+        int Interior() const { return mNodes / 2 - 1; }
         int Leaves() const { return (mNodes / 2) + 1; }
         
@@ -246 +246 @@
 
 
+        /** Create bounding box and root.
+        */
+        void InitialiseObjectSpaceSubdivision(const ObjectContainer &objects);
+
+        /** Returns memory usage of object space hierarchy.
+        */
+        float GetObjectSpaceMemUsage() const;
+
         //////////////////////////////
         // the main loop
@@ -255 +263 @@
                                                  const VssRayContainer &sampleRays,
                                                  const ObjectContainer &objects,
-                                                 AxisAlignedBox3 *forcedViewSpace,
-                                                 SubdivisionCandidate *firstVsp);
+                                                 AxisAlignedBox3 *forcedViewSpace);
         
         /** This is for interleaved construction using some objects 
@@ -307 +314 @@
                                                          const float totalRenderCost,
                                                          const int totalPvsEntries, 
-                                                         const int memory,
+                                                         const float memory,
                                                          const float renderCostPerStorage);
 
@@ -365 +372 @@
         /** Reset the split queue, i.e., reevaluate the split candidates.
         */
-    void ResetQueue();
+    void ResetQueue(SplitQueue &splitQueue, const bool recomputeSplitPlane);
 
         /** After the suddivision has ended, do some final tasks.
@@ -374 +381 @@
         */
         int GetObjectSpaceSubdivisionDepth() const;
+
+        /** Returns number of leaves in object space subdivision.
+        */
+        int GetObjectSpaceSubdivisionLeaves() const;
 
         /** Construct object space partition interleaved with view space partition.
@@ -401 +412 @@
                                                          AxisAlignedBox3 *forcedViewSpace);
 
+        /** Based on a given subdivision, we try to optimize using an
+                multiple iteration over view and object space.
+        */
+        void OptimizeMultiLevel(const VssRayContainer &sampleRays,                                                                                       
+                                                        const ObjectContainer &objects,
+                                                        AxisAlignedBox3 *forcedViewSpace);
+
         /** Reset the object space subdivision. 
                 E.g., deletes hierarchy and resets stats.
@@ -471 +489 @@
         ////////////////////
 
+        int mMinStepsOfSameType;
+
         /// statistics about the hierarchy
         HierarchyStatistics mHierarchyStats;
@@ -490 +510 @@
         */
         bool mUseMultiLevelConstruction;
+
         /// number of iteration steps for multilevel approach   
         int mNumMultiLevels;
+
         /** if split plane should be recomputed for the repair.
                 Otherwise only the priority is recomputed, the

GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

@@ -2599 +2599 @@
 {
         Environment::GetSingleton()->GetIntValue("BspTree.Construction.samples", mInitialSamples);
+
         mBspTree->SetViewCellsManager(this);
         mBspTree->SetViewCellsTree(mViewCellsTree);
@@ -4774 +4775 @@
 : ViewCellsManager(vcTree), mHierarchyManager(hm)
 {
-        Environment::GetSingleton()->GetIntValue("VspTree.Construction.samples", mInitialSamples);
+        Environment::GetSingleton()->GetIntValue("Hierarchy.Construction.samples", mInitialSamples);
 
         mHierarchyManager->SetViewCellsManager(this);

GTP/trunk/Lib/Vis/Preprocessing/src/VspTree.cpp

@@ -559 +559 @@
 
 
-// TODO: return memory usage in MB
+// $$matt temporary: number of rayrefs + pvs should be in there, but
+// commented out for testing
 float VspTree::GetMemUsage() const
 {
         return (float)
-                 (sizeof(VspTree) + 
-                  mVspStats.Leaves() * sizeof(VspLeaf) + 
-                  mCreatedViewCells * sizeof(VspViewCell) +
-                  mVspStats.pvs * sizeof(PvsData) +
-                  mVspStats.Interior() * sizeof(VspInterior) +
-                  mVspStats.accumRays * sizeof(RayInfo)) / (1024.0f * 1024.0f);
+                 (sizeof(VspTree)
+                  + mVspStats.Leaves() * sizeof(VspLeaf) 
+                  + mVspStats.Leaves() * sizeof(VspViewCell)
+                  + mVspStats.Interior() * sizeof(VspInterior)
+                  //+ mVspStats.pvs * sizeof(PvsData)
+                  //+ mVspStats.rayRefs * sizeof(RayInfo)
+                  ) / (1024.0f * 1024.0f);
 }
 
@@ -739 +741 @@
         {
                 // view cell is created during subdivision
-                //CreateViewCell(tData); 
-
                 VspLeaf *leaf = dynamic_cast<VspLeaf *>(newNode);
                 ViewCell *viewCell = leaf->GetViewCell();
@@ -1858 +1858 @@
 
         // accumulate rays to compute rays /  leaf
-        mVspStats.accumRays += (int)data.mRays->size();
+        mVspStats.rayRefs += (int)data.mRays->size();
 
         if (data.mPvs < mTermMinPvs)
@@ -2834 +2834 @@
 
 
+void VspTree::Initialise(const VssRayContainer &rays,
+                                                 AxisAlignedBox3 *forcedBoundingBox)
+{
+        ComputeBoundingBox(rays, forcedBoundingBox);
+
+        VspLeaf *leaf = new VspLeaf();
+        mRoot = leaf;
+
+        VspViewCell *viewCell = new VspViewCell();
+    leaf->SetViewCell(viewCell);
+
+        // set view cell values
+        viewCell->mLeaves.push_back(leaf);
+
+        viewCell->SetVolume(mBoundingBox.GetVolume());
+    leaf->mProbability = mBoundingBox.GetVolume();
+}
+
+
 SubdivisionCandidate *VspTree::PrepareConstruction(const VssRayContainer &sampleRays,
                                                                                                    RayInfoContainer &rays)
@@ -2846 +2865 @@
         // initialise termination criteria
         mTermMinProbability *= mBoundingBox.GetVolume();
+        
         // get clipped rays
         PreprocessRays(sampleRays, rays);
@@ -2852 +2872 @@
         const int pvsSize = EvalPvsSize(rays);
         
+        // root and bounding box were already constructed
+        VspLeaf *leaf = dynamic_cast<VspLeaf *>(mRoot);
 
         //////////
@@ -2858 +2880 @@
         const float prop = mBoundingBox.GetVolume();
         
-        // we assume that leaf was already created
-        VspLeaf *leaf = new VspLeaf();
-        mRoot = leaf;
-
         // first vsp traversal data
-        VspTraversalData vData(leaf, 0, &rays, pvsSize, prop, mBoundingBox);
-
-        // create first view cell
-        CreateViewCell(vData, false);
+        VspTraversalData vData(leaf, 0, &rays, pvsSize, prop, mBoundingBox);
+
 
 #if WORK_WITH_VIEWCELL_PVS

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

@@ -79 +79 @@
         /// number of invalid leaves
         int invalidLeaves;
-        /// accumulated number of rays refs
-        int accumRays;
+        /// number of rays refs
+        int rayRefs;
         /// overall pvs size
         int pvs;
@@ -100 +100 @@
         // TODO: computation wrong
         double AvgDepth() const { return accumDepth / (double)Leaves();}; 
-        double AvgRays() const { return accumRays / (double)Leaves();}; 
+        double AvgRays() const { return rayRefs / (double)Leaves();}; 
 
         void Reset() 
@@ -124 +124 @@
                 maxPvs = 0;
                 invalidLeaves = 0;
-                accumRays = 0;
+                rayRefs = 0;
                 maxObjectRefs = 0;
                 mGlobalCostMisses = 0;
@@ -996 +996 @@
         int EvalContributionToPvs(KdLeaf *leaf) const;
 
+        /** Creates new root of hierarchy and computes bounding box.
+                Has to be called before the preparation of the subdivision.
+        */
+        void Initialise(const VssRayContainer &rays,
+                                        AxisAlignedBox3 *forcedBoundingBox);
 
 protected:

GTP/trunk/Lib/Vis/Preprocessing/src/main.cpp

@@ -112 +112 @@
                 else
                 {
-                        strippedFilename = string(StripPath(currentFile.c_str()));
+                        char *str = StripPath(currentFile.c_str());
+                        strippedFilename = string(str);
+
+                        delete []str;
                 }