Changeset 1294

Timestamp:

08/29/06 17:34:19 (18 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/Lib/Vis/Preprocessing/src

Files:

• BvHierarchy.cpp (modified) (13 diffs)
• BvHierarchy.h (modified) (11 diffs)
• Environment.cpp (modified) (3 diffs)
• GzBinFileInputStream.h (modified) (3 diffs)
• HierarchyManager.cpp (modified) (15 diffs)
• HierarchyManager.h (modified) (1 diff)
• OspTree.cpp (modified) (2 diffs)
• Preprocessor.cpp (modified) (11 diffs)
• ViewCellsManager.h (modified) (8 diffs)
• ViewCellsParser.cpp (modified) (2 diffs)
• VspTree.cpp (modified) (13 diffs)
• VspTree.h (modified) (4 diffs)
• main.cpp (modified) (1 diff)

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

@@ -213 +213 @@
         Environment::GetSingleton()->GetFloatValue("BvHierarchy.Termination.minGlobalCostRatio",
                 mTermMinGlobalCostRatio);
-        Environment::GetSingleton()->GetIntValue("BvHierarchy.Termination.globalCostMissTolerance", mTermGlobalCostMissTolerance);
+        Environment::GetSingleton()->GetIntValue("BvHierarchy.Termination.globalCostMissTolerance", 
+                mTermGlobalCostMissTolerance);
 
         //-- factors for bsp tree split plane heuristics
@@ -285 +286 @@
         // add the new nodes to the tree
         BvhInterior *node = new BvhInterior(tData.mBoundingBox, leaf->GetParent());
-        //cout << "bbox: " << tData.mBoundingBox << endl;
-
+        
 
         //-- the front and back traversal data is filled with the new values
@@ -292 +292 @@
         frontData.mDepth = backData.mDepth = tData.mDepth + 1;
 
-        frontData.mBoundingBox = ComputeBoundingBox(frontObjects, &(tData.mBoundingBox));
-        backData.mBoundingBox = ComputeBoundingBox(backObjects, &(tData.mBoundingBox));
+        frontData.mBoundingBox = ComputeBoundingBox(frontObjects, &tData.mBoundingBox);
+        backData.mBoundingBox = ComputeBoundingBox(backObjects, &tData.mBoundingBox);
         
         /////////////
@@ -354 +354 @@
         if (!LocalTerminationCriteriaMet(tData) && !globalCriteriaMet)
         {       
+                //-- continue subdivision
+
                 BvhTraversalData tFrontData;
                 BvhTraversalData tBackData;
-
-                //-- continue subdivision
-                
+                        
                 // create new interior node and two leaf node
                 newNode = SubdivideNode(sc->mFrontObjects,
@@ -392 +392 @@
 
                 // delete old leaf node
-                DEL_PTR(tData.mNode);
+                //DEL_PTR(tData.mNode);
         }
 
@@ -409 +409 @@
                         CollectRays(leaf->mObjects, leaf->mVssRays);
                 }
-        }
-        
-        tData.Clear(); // cleanup
+
+                // detach node so it won't get deleted
+                tData.mNode = NULL;
+        }
         
         return newNode;
@@ -447 +448 @@
         const float renderCostDecr = oldRenderCost - newRenderCost;
 
-        //Debug << "render cost decr: " << renderCostDecr << endl;
+        Debug << "\nbvh render cost decr: " << renderCostDecr << endl;
         splitCandidate.SetRenderCostDecrease(renderCostDecr);
 
-#if 0
-        const float priority = (float)-data.mDepth;
+#if 1
+        const float priority = (float)-splitCandidate.mParentData.mDepth;
 #else   
         // take render cost of node into account 
@@ -469 +470 @@
         // matt: TODO
         return ( 0
-                || (data.mNode->mObjects.size() < mTermMinObjects)
-                || (data.mProbability <= mTermMinProbability)
-                || (data.mDepth >= mTermMaxDepth)
+                //|| ((int)data.mNode->mObjects.size() < mTermMinObjects)
+                //|| (data.mProbability <= mTermMinProbability)
+                //|| (data.mDepth >= mTermMaxDepth)
                  );
 }
@@ -536 +537 @@
                 AxisAlignedBox3 box = obj->GetBox();
 
-                const float objMid = (box.Max(axis) + box.Min(axis)) * 0.5;
+                const float objMid = (box.Max(axis) + box.Min(axis)) * 0.5f;
 
                 // object mailed => belongs to back objects
@@ -936 +937 @@
 
         const float viewSpaceVol = mVspTree->GetBoundingBox().GetVolume();
-        Debug << "\n***** eval render cost *********\n" 
+        /*Debug << "\nbvh render cost\n" 
                   << "back p: " << pBack / viewSpaceVol << " front p " << pFront / viewSpaceVol << endl
-                  << "new rc: " << newRenderCost / viewSpaceVol << endl;
+                  << "new rc: " << newRenderCost / viewSpaceVol << endl;*/
                  
 
@@ -1319 +1320 @@
 }
 
+void BvHierarchy::CreateRoot(const ObjectContainer &objects)
+{
+        //-- create new root
+        AxisAlignedBox3 box = ComputeBoundingBox(objects);
+        BvhLeaf *bvhleaf = new BvhLeaf(box, NULL, (int)objects.size());
+        bvhleaf->mObjects = objects;
+
+        mRoot = bvhleaf;
+
+        // associate root with current objects
+        AssociateObjectsWithLeaf(bvhleaf);
+}
+
 
 SubdivisionCandidate *BvHierarchy::PrepareConstruction(const VssRayContainer &sampleRays,
-                                                                                                           const ObjectContainer &objects
-                                                                                                           //,AxisAlignedBox3 *forcedObjectSpace
-                                                                                                           )
+                                                                                                           const ObjectContainer &objects)
 {
         // note matt: we assume that we have objects sorted by their id
@@ -1332 +1344 @@
 
         // compute bounding box from objects
-        mBoundingBox = ComputeBoundingBox(objects);
+        // we assume that root was already created
+        mBoundingBox = mRoot->GetBoundingBox();
+        BvhLeaf *bvhleaf = dynamic_cast<BvhLeaf *>(mRoot);
 
         mTermMinProbability *= mBoundingBox.GetVolume();
         mGlobalCostMisses = 0;
         
-        //-- create new root
-
-        BvhLeaf *bvhleaf = new BvhLeaf(mBoundingBox, NULL, (int)objects.size());
-        bvhleaf->mObjects = objects;
-        mRoot = bvhleaf;
-
         // only rays intersecting objects in node are interesting
         AssociateObjectsWithRays(sampleRays);
-        // associate root with current objects
-        AssociateObjectsWithLeaf(bvhleaf);
-
-        //-- add first candidate for object space partition
-        
+        
+
         // probabilty is voume of all "seen" view cells
 #if 1
-        const float prop = EvalViewCellsVolume(bvhleaf->mObjects);
+        const float prop = EvalViewCellsVolume(objects);
 #else
         const float prop = GetBoundingBox().GetVolume();
@@ -1360 +1365 @@
         BvhTraversalData oData(bvhleaf, 0, mBoundingBox, prop);
 
-        //-- first split candidate
+        //-- add first candidate for object space partition     
         BvhSubdivisionCandidate *oSubdivisionCandidate = 
                 new BvhSubdivisionCandidate(oData);

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

@@ -134 +134 @@
         virtual bool IsLeaf() const = 0;
 
-        //virtual int Type() const = 0;
-
         /** Determines whether this node is a root
                 @return true if root
@@ -205 +203 @@
         */
         bool IsLeaf() const;
-        //int Type() const;
-
+        
         BvhNode *GetBack() { return mBack; }
         BvhNode *GetFront() { return mFront; }
@@ -249 +246 @@
         bool IsLeaf() const;
         
-        //int Type() const;
-
         SubdivisionCandidate *GetSubdivisionCandidate() const 
         { 
@@ -292 +287 @@
         {  
         public:
-                /// the current node
-                BvhLeaf *mNode;
-                /// current depth
-                int mDepth;
-                /// the probability that this node is seen
-                float mProbability;
-                /// the bounding box of the node
-                AxisAlignedBox3 mBoundingBox;
-                /// how often this branch has missed the max-cost ratio
-                int mMaxCostMisses;
-                /// current axis
-                int mAxis;
-                /// current priority
-                float mPriority;
-
-
+                
                 BvhTraversalData():
                 mNode(NULL),
@@ -335 +315 @@
                 float GetCost() const
                 {
-                        //cout << mPriority << endl;
                         return mPriority;
                 }
@@ -342 +321 @@
                 void Clear()
                 {
-                        //DEL_PTR(mRays);
+                        DEL_PTR(mNode);
                 }
+
+                /// the current node
+                BvhLeaf *mNode;
+                /// current depth
+                int mDepth;
+                /// the probability that this node is seen
+                float mProbability;
+                /// the bounding box of the node
+                AxisAlignedBox3 mBoundingBox;
+                /// how often this branch has missed the max-cost ratio
+                int mMaxCostMisses;
+                /// current axis
+                int mAxis;
+                /// current priority
+                float mPriority;
+
 
                 friend bool operator<(const BvhTraversalData &a, const BvhTraversalData &b)
@@ -356 +351 @@
         {  
         public:
-                static BvHierarchy *sBvHierarchy;
-
-                /// parent data
-                BvhTraversalData mParentData;
-                ObjectContainer mFrontObjects;
-                ObjectContainer mBackObjects;
-
-                BvhSubdivisionCandidate(const BvhTraversalData &tData): mParentData(tData)
+
+        BvhSubdivisionCandidate(const BvhTraversalData &tData): mParentData(tData)
                 {};
+
+                ~BvhSubdivisionCandidate() { mParentData.Clear(); }
 
                 int Type() const { return OBJECT_SPACE; }
@@ -377 +368 @@
                         return sBvHierarchy->GlobalTerminationCriteriaMet(mParentData);
                 }
-
 
                 BvhSubdivisionCandidate(
@@ -385 +375 @@
                 mFrontObjects(frontObjects), mBackObjects(backObjects), mParentData(tData)
                 {}
+
+                
+                static BvHierarchy *sBvHierarchy;
+
+                /// parent data
+                BvhTraversalData mParentData;
+                ObjectContainer mFrontObjects;
+                ObjectContainer mBackObjects;
         };
 
@@ -401 +399 @@
         };
 
-        //typedef std::priority_queue<VspTraversalData> VspOspTraversalQueue;
 
         /** Default constructor creating an empty tree.
@@ -616 +613 @@
         float GetMemUsage() const;
 
-
+        /** Creates new root of hierarchy.
+        */
+        void CreateRoot(const ObjectContainer &objects);
 
         /////////////////////////////

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

@@ -1497 +1497 @@
                 "0");
 
-        RegisterOption("ViewCells.storeKdPvs",
-                optBool, 
-                "view_cells_store_kd_pvs=", 
-                "false");
-        
-
+        
         /************************************************************************************/
         /*                         Render simulation related options                        */
@@ -2220 +2215 @@
                                         "vsp_construction_max_band=",
                                         "0.99");
-
-        RegisterOption("VspTree.useKdPvsForHeuristics",
-                                        optBool,
-                                        "vsp_use_kd_pvs_for_heuristics=",
-                                        "true");
-
-        RegisterOption("VspTree.storeKdPvs",
-                                        optBool,
-                                        "vsp_store_kd_pvs=",
-                                        "true");
         
         RegisterOption("VspTree.maxTests",
@@ -2241 +2226 @@
 /*           Object space partition tree related options               */
 /***********************************************************************/
+
 
         RegisterOption("OspTree.Construction.randomize",

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

@@ -111 +111 @@
     //  Unimplemented constructors and operators
     // -----------------------------------------------------------------------
+
     GzBinFileInputStream(const GzBinFileInputStream&);
     GzBinFileInputStream& operator=(const GzBinFileInputStream&);   
@@ -121 +122 @@
     //      per platform.
     // -----------------------------------------------------------------------
+
     FileHandle              fSource;
     MemoryManager* const    fMemoryManager;
@@ -129 +131 @@
 //  GzBinFileInputStream: Getter methods
 // ---------------------------------------------------------------------------
+
 inline bool GzBinFileInputStream::getIsOpen() const
 {
-        return (mStream.is_open());//(fSource != 0);
+        return bool (mStream.is_open());//(fSource != 0);
 }
 

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

@@ -97 +97 @@
 
         Environment::GetSingleton()->GetIntValue(
+                "Hierarchy.Termination.maxLeaves", mTermMaxLeaves);
+
+        Environment::GetSingleton()->GetIntValue(
                 "Hierarchy.Construction.type", mConstructionType);
 
-        //Debug << "max depth: " << mTermMaxDepth << endl;
+        Debug << "******** Hierachy Manager Parameters ***********" << endl;
+        Debug << "max leaves: " << mTermMaxLeaves << endl;
         Debug << "min global cost ratio: " << mTermMinGlobalCostRatio << endl;
         Debug << "global cost miss tolerance: " << mTermGlobalCostMissTolerance << endl;
@@ -145 +149 @@
                                                                                    RayInfoContainer &objectSpaceRays)
 {
-        SubdivisionCandidate *vsc = 
-                mVspTree->PrepareConstruction(sampleRays, forcedViewSpace, viewSpaceRays);
-
-        mTQueue.Push(vsc);
-
-    SubdivisionCandidate *osc;
+        mHierarchyStats.Reset();
+        mHierarchyStats.Start();
 
         switch (mObjectSpaceSubdivisonType)
         {
         case KD_BASED_OBJ_SUBDIV:
-                osc = mOspTree->PrepareConstruction(sampleRays, objects, objectSpaceRays);
-                mTQueue.Push(osc);
-                break;
-        case BV_BASED_OBJ_SUBDIV:
-                osc = mBvHierarchy->PrepareConstruction(sampleRays, objects);
-                mTQueue.Push(osc);
-                break;
-        default:
-                break;
-        }
+                {
+                        SubdivisionCandidate *vsc = 
+                                mVspTree->PrepareConstruction(sampleRays, forcedViewSpace, viewSpaceRays);
+                        mTQueue.Push(vsc);
+
+                        SubdivisionCandidate *osc;
+                        osc = mOspTree->PrepareConstruction(sampleRays, objects, objectSpaceRays);
+                        mTQueue.Push(osc);
+                }
+                break;
+        case BV_BASED_OBJ_SUBDIV:
+                {
+                        mBvHierarchy->CreateRoot(objects);
+
+                        SubdivisionCandidate *vsc = 
+                                mVspTree->PrepareConstruction(sampleRays, forcedViewSpace, viewSpaceRays);
+                        mTQueue.Push(vsc);
+
+                        SubdivisionCandidate *osc;
+                        osc = mBvHierarchy->PrepareConstruction(sampleRays, objects);
+                        mTQueue.Push(osc);
+                }
+                break;
+        default:
+                break;
+        }
+
+        mTotalCost = (float)objects.size();
+        Debug << " setting total cost to " << mTotalCost << endl;
 }
 
@@ -211 +230 @@
 {
         return (0
-                || (mHierarchyStats.Leaves() >= mMaxLeaves) 
-                || (mGlobalCostMisses >= mTermGlobalCostMissTolerance)
-                ||      candidate->GlobalTerminationCriteriaMet()
+                || (mHierarchyStats.Leaves() >= mTermMaxLeaves) 
+                //|| (mGlobalCostMisses >= mTermGlobalCostMissTolerance)
+                //||    candidate->GlobalTerminationCriteriaMet()
                 );
 }
@@ -250 +269 @@
                                                 *objectSpaceRays);
 
-        mHierarchyStats.Reset();
-        mHierarchyStats.Start();
 
         cout << "Constructing view space / object space tree ... \n";
         const long startTime = GetTime();       
         
-        RunConstruction(true);
+        const bool repairQueue = true;
+
+        // process object space candidates
+        RunConstruction(repairQueue);
 
         cout << "finished in " << TimeDiff(startTime, GetTime())*1e-3 << " secs" << endl;
@@ -264 +284 @@
 
 
+void HierarchyManager::ConstructBvHierarchy(const VssRayContainer &sampleRays,
+                                                                                        const ObjectContainer &objects) 
+
+{
+        Debug << "\n$$$$$$$$$ bv hierarchy construction $$$$$$$$$$\n" << endl;
+        cout << "starting bv hierarchy construction ... " << endl;
+
+        mBvHierarchy->CreateRoot(objects);
+
+        // compute first candidate
+        SubdivisionCandidate *sc =
+                mBvHierarchy->PrepareConstruction(sampleRays, objects);
+
+        mTotalCost = mBvHierarchy->mTotalCost;
+        Debug << "reseting cost, new total cost: " << mTotalCost << endl;
+        
+    mTQueue.Push(sc);
+
+        mBvHierarchy->mBvhStats.Reset();
+        mBvHierarchy->mBvhStats.Start();
+
+        const long startTime = GetTime();
+        const bool repairQueue = false;
+
+        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+
+        mBvHierarchy->mBvhStats.Stop();
+}
+
+
+void HierarchyManager::ConstructOspTree(const VssRayContainer &sampleRays,
+                                                                                const ObjectContainer &objects) 
+
+{
+        RayInfoContainer *objectSpaceRays = new RayInfoContainer();
+
+        Debug << "\n$$$$$$$$$ osp tree construction $$$$$$$$$$\n" << endl;
+        cout << "starting osp tree construction ... " << endl;
+
+        // start with one big kd cell - all objects can be seen from everywhere
+        // note: only true for view space = object space
+
+        // compute first candidate
+        SubdivisionCandidate *osc =
+                mOspTree->PrepareConstruction(sampleRays, objects, *objectSpaceRays);
+
+        mTotalCost = mOspTree->mTotalCost;
+        Debug << "reseting cost, new total cost: " << mTotalCost << endl;
+        
+    mTQueue.Push(osc);
+
+        mOspTree->mOspStats.Reset();
+        mOspTree->mOspStats.Start();
+
+        const long startTime = GetTime();
+                
+        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+
+        mOspTree->mOspStats.Stop();
+
+        //////////////////////////
+        // matt: only for debugging purpose
+
+        const float rc = mOspTree->EvalRenderCost(sampleRays);
+
+        Debug << "My render cost evalulation: " << rc << endl;
+}
+
+
+
 bool HierarchyManager::ApplySubdivisionCandidate(SubdivisionCandidate *sc)
 {
         const bool globalTerminationCriteriaMet = GlobalTerminationCriteriaMet(sc);
-
         const bool vspSplit = (sc->Type() == SubdivisionCandidate::VIEW_SPACE);
 
@@ -289 +378 @@
                 {
                         BvhNode *n = mBvHierarchy->Subdivide(mTQueue, sc, globalTerminationCriteriaMet);
+
                         if (n->IsLeaf()) // local or global termination criteria failed
                                 return false;
@@ -305 +395 @@
         while (!FinishedConstruction())
         {
-                SubdivisionCandidate *splitCandidate = NextSubdivisionCandidate();
+                mCurrentCandidate = NextSubdivisionCandidate();
             
-                mTotalCost -= splitCandidate->GetRenderCostDecrease();
+                mTotalCost -= mCurrentCandidate->GetRenderCostDecrease();
 
                 // cost ratio of cost decrease / totalCost
-                const float costRatio = splitCandidate->GetRenderCostDecrease() / mTotalCost;
+                const float costRatio = mCurrentCandidate->GetRenderCostDecrease() / mTotalCost;
 
                 //Debug << "ratio: " << costRatio << " min ratio: " << mTermMinGlobalCostRatio << endl;
@@ -318 +408 @@
                 //-- subdivide leaf node
 
-                if (ApplySubdivisionCandidate(splitCandidate))
+                if (ApplySubdivisionCandidate(mCurrentCandidate))
                 {
                         mHierarchyStats.nodes += 2;
 
                         // subdivision successful
-                        EvalSubdivisionStats(*splitCandidate);
+                        EvalSubdivisionStats(*mCurrentCandidate);
                 
                         // reevaluate candidates affected by the split
@@ -330 +420 @@
                         if (repair) RepairQueue();
 
-                        cout << "candidate: " << splitCandidate->Type() << ", priority: " 
-                                 << splitCandidate->GetPriority() << endl;
-                }
-
-                DEL_PTR(splitCandidate);
+                        cout << "candidate: " << mCurrentCandidate->Type() << ", priority: " 
+                                 << mCurrentCandidate->GetPriority() << endl;
+                }
+
+                DEL_PTR(mCurrentCandidate);
         }
 }
@@ -345 +435 @@
 
 
-void HierarchyManager::CollectObjectSpaceDirtyList(
-        SubdivisionCandidateContainer &dirtyList)
+void HierarchyManager::CollectObjectSpaceDirtyList(SubdivisionCandidateContainer &dirtyList)
 {
         switch (mObjectSpaceSubdivisonType)
@@ -383 +472 @@
 void HierarchyManager::CollectDirtyCandidates(SubdivisionCandidateContainer &dirtyList)
 {       
+        Debug << "here65" << endl;
         // we have either a object space or view space split
         if (mCurrentCandidate->Type() == SubdivisionCandidate::VIEW_SPACE)
         {
+                Debug << "collected view space candidate" << endl;
                 CollectViewSpaceDirtyList(dirtyList);
         }
         else // object space split
         {       
+                Debug << "collecting object space candidate" << endl;
                 CollectObjectSpaceDirtyList(dirtyList);
         }
@@ -423 +515 @@
         for (sit = dirtyList.begin(); sit != sit_end; ++ sit)
         {
+                Debug << "here4423" << endl;
                 SubdivisionCandidate* sc = *sit;
 
@@ -428 +521 @@
 
                 // reevaluate
-                sc->EvalPriority();
+                //sc->EvalPriority();
 
                 // reinsert
@@ -553 +646 @@
         RayInfoContainer *viewSpaceRays = new RayInfoContainer();
         
+
         /////////////////////////////////////////////////////////////
         // view space space partition
         /////////////////////////////////////////////////////////////
 
+
         // use objects for evaluating vsp tree construction
         const int savedobjectSpaceSubdivisionType = mObjectSpaceSubdivisonType;
@@ -610 +705 @@
                 break;
         }
-}
-
-
-void HierarchyManager::ConstructBvHierarchy(const VssRayContainer &sampleRays,
-                                                                                        const ObjectContainer &objects
-                                                                                        //,AxisAlignedBox3 *forcedViewSpace
-                                                                                        ) 
-
-{
-        Debug << "\n$$$$$$$$$ bv hierarchy construction $$$$$$$$$$\n" << endl;
-        cout << "starting bv hierarchy construction ... " << endl;
-
-        //ObjectContainer obj = objects;
-
-        // compute first candidate
-        SubdivisionCandidate *sc =
-                mBvHierarchy->PrepareConstruction(sampleRays, objects);
-
-        mTotalCost = mBvHierarchy->mTotalCost;
-        Debug << "reseting cost, new total cost: " << mTotalCost << endl;
-        
-    mTQueue.Push(sc);
-
-        mBvHierarchy->mBvhStats.Reset();
-        mBvHierarchy->mBvhStats.Start();
-
-        const long startTime = GetTime();
-        const bool repairQueue = false;
 
         // process object space candidates
         RunConstruction(repairQueue);
-        
-        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-
-        mBvHierarchy->mBvhStats.Stop();
-}
-
-
-void HierarchyManager::ConstructOspTree(const VssRayContainer &sampleRays,
-                                                                                const ObjectContainer &objects) 
-
-{
-        RayInfoContainer *objectSpaceRays = new RayInfoContainer();
-
-        Debug << "\n$$$$$$$$$ osp tree construction $$$$$$$$$$\n" << endl;
-        cout << "starting osp tree construction ... " << endl;
-
-        // start with one big kd cell - all objects can be seen from everywhere
-        // note: only true for view space = object space
-
-        // compute first candidate
-        SubdivisionCandidate *osc =
-                mOspTree->PrepareConstruction(sampleRays, objects, *objectSpaceRays);
-
-        mTotalCost = mOspTree->mTotalCost;
-        Debug << "reseting cost, new total cost: " << mTotalCost << endl;
-        
-    mTQueue.Push(osc);
-
-        mOspTree->mOspStats.Reset();
-        mOspTree->mOspStats.Start();
-
-        const long startTime = GetTime();
-        const bool repairQueue = false;
-        
-        // process object space candidates
-        RunConstruction(repairQueue);
-        
-        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-
-        mOspTree->mOspStats.Stop();
-
-        //////////////////////////
-        // matt: only for debugging purpose
-
-        const float rc = mOspTree->EvalRenderCost(sampleRays);
-
-        Debug << "My render cost evalulation: " << rc << endl;
-}
-
-
-
-}
+}
+
+
+}

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

@@ -290 +290 @@
         HierarchyStatistics mHierarchyStats;
 
-        int mMaxLeaves;
+        int mTermMaxLeaves;
         ofstream mSubdivisionStats;
 };

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

@@ -895 +895 @@
         }
 
-        Debug << "here32 " << touchedViewCells.size() << endl;
+        Debug << "here32 " << (int)touchedViewCells.size() << endl;
         return renderCost;
 }
@@ -1793 +1793 @@
                 }
         }
-        Debug << "here65 " << touchedObjects.size() << endl;
+        Debug << "here65 " << (int)touchedObjects.size() << endl;
         ObjectContainer::const_iterator it, it_end = touchedObjects.end();
         for (it = touchedObjects.begin(); it != it_end; ++ it)

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

@@ -475 +475 @@
 }
 
+
 HierarchyManager *Preprocessor::CreateHierarchyManager(const char *name)
 {
@@ -850 +851 @@
                                                                          )
 {
+#ifdef GTP_INTERNAL
         VssRay *vssRay  = NULL;
         int hits = 0;
@@ -859 +861 @@
         
         double normal[3];
-#ifdef GTP_INTERNAL
+
         hittriangle = mlrtaIntersectAS(&viewPoint.x,
                                                                    &direction.x,
                                                                    normal,
                                                                    dist);
-#else
-        hittriangle = -1;
-#endif
+
         if (hittriangle !=-1 ) {
           if (hittriangle >= mFaceParents.size())
@@ -881 +881 @@
         }
 
+        
         Vector3 dir = -direction;
-#ifdef GTP_INTERNAL
         hittriangle = mlrtaIntersectAS(&viewPoint.x,
                                                                    &dir.x,
                                                                    normal,
                                                                    dist);
-#else
-        hittriangle = -1;
-#endif
 
         if (hittriangle !=-1 ) {
@@ -913 +910 @@
                                           box
                                           );
+#else
+        return -1;
+#endif
 }
 
@@ -929 +929 @@
                 return 0;
         
+#ifdef GTP_INTERNAL
         float pforg[3];
         float pfdir[3];
@@ -936 +937 @@
         pfdir[0] = direction[0]; pfdir[1] = direction[1]; pfdir[2] = direction[2];
 
-        float dist = 0;
-#ifdef GTP_INTERNAL
+        float dist;
         const int hittriangle = mlrtaIntersectAS(pforg, pfdir, pfnorm, dist);
-#else
-        const int hittriangle = -1;
-#endif
 
         if (hittriangle == -1)
@@ -970 +967 @@
           }
         }
+
+#else
+        const int hittriangle = -1;
+        return NULL;
+#endif
+
+        
         
 }
@@ -1330 +1334 @@
         {
         case INTEL_RAYCASTER: {
-          float dist;
+         
           int hittriangle;
+          
+
+#ifdef GTP_INTERNAL
+          float dist; 
           double n[3];
 
-#ifdef GTP_INTERNAL
           hittriangle = mlrtaIntersectAS(&viewPoint.x,
                                                                          &direction.x,
@@ -1340 +1347 @@
                                                                          dist);
 
-#else
-        hittriangle = -1;
-#endif
-
-          if (hittriangle !=-1 ) {
+           if (hittriangle !=-1 ) {
                 if (hittriangle >= mFaceParents.size())
                   cerr<<"Warning: traingle index out of range! "<<hittriangle<<endl;
@@ -1353 +1356 @@
                 }
           }
+#else
+        hittriangle = -1;
+#endif
+
+         
           break;
         }

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

@@ -227 +227 @@
                                                           ) = 0;
 
+        /** Returns a stats about the global pvs.
+        */
         virtual void GetPvsStatistics(PvsStatistics &stat);
 
@@ -378 +380 @@
                                                                                 vector<MergeCandidate> &candidates);
 
+        /** Collects n view cells and stores it as the active view cells.
+        */
         void CollectViewCells(const int n);
 
@@ -453 +457 @@
         ////////////////////////////////////////////////////////7
         // visiblity filter options
+
         // TODO: write own visibiltiy filter class
         void ApplyFilter(KdTree *kdTree,
@@ -472 +477 @@
         float GetAbsFilterWidth();
 
-        
         /** Returns the bounding box of filter width.
         */
         AxisAlignedBox3 GetFilterBBox(const Vector3 &viewPoint, const float width) const;
 
+        //////////////////////////////////////////////////////////////////
 
         /** Returns true if the view cell is equivalent to a 
@@ -482 +487 @@
                 view cell.
                 e.g. to see if the spatial tree can be reduced on this location
+                note: not implemented
         */
         virtual bool EqualToSpatialNode(ViewCell *viewCell) const;
@@ -502 +508 @@
 protected:
 
-        /** Exports bounding boxes as xml stream
-        */
-        //bool ExportBoundingBoxes(ofstream &xmlstream, const ObjectContainer &objects) const;
-
         /** Intersects box with the tree and returns the number of intersected boxes.
                 @returns number of view cells found
@@ -520 +522 @@
         bool ViewCellsTreeConstructed() const;
 
+        /** Requests preprocessor to cast samplesPerPass samples of a specific type.
+        */
         int CastPassSamples(const int samplesPerPass, 
                                                 const int sampleType, 
@@ -717 +721 @@
                                                 ViewCellContainer &viewcells);
         
+        /** Returns the probability that the view point lies
+                in this view cells.
+        */
         float GetProbability(ViewCell *viewCell);
-        
-
-        /** Get a viewcell containing the specified point 
+
+        /** Get a viewcell containing the specified point.
         */
         ViewCell *GetViewCell(const Vector3 &point, const bool active = false) const;
 
+        /** Creates mesh for this view cell.
+        */
         void CreateMesh(ViewCell *vc);
 

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

@@ -1243 +1243 @@
 
                 if (attrName == "min") 
-                {cout << "here6" << endl;
+                {
                         sscanf(ptr, "%f %f %f", &minBox.x, &minBox.y, &minBox.z);
                 }
                 if (attrName == "max") 
-                {cout << "here7" << endl;
+                {
                         sscanf(ptr, "%f %f %f", &maxBox.x, &maxBox.y, &maxBox.z);
                 }
@@ -1262 +1262 @@
         }
         else
-        {cout << "here18" << endl;
+        {
                 mHierarchyManager->mBvHierarchy->mRoot = interior;
         }
-cout << "here28" << endl;
+
         mCurrentBvhNode = interior;
 }

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

@@ -527 +527 @@
 inline bool VspTree::LocalTerminationCriteriaMet(const VspTraversalData &data) const
 {
-        const bool localTerminationCriteriaMet = (
-                ((int)data.mRays->size() <= mTermMinRays) ||
-                (data.mPvs <= mTermMinPvs)   ||
-                (data.mProbability <= mTermMinProbability) ||
-                (data.GetAvgRayContribution() > mTermMaxRayContribution) ||
-                (data.mDepth >= mTermMaxDepth)
+        const bool localTerminationCriteriaMet = (0
+                //|| ((int)data.mRays->size() <= mTermMinRays)
+                //|| (data.mPvs <= mTermMinPvs)
+                //|| (data.mProbability <= mTermMinProbability)
+                //|| (data.GetAvgRayContribution() > mTermMaxRayContribution)
+                //|| (data.mDepth >= mTermMaxDepth)
                 );
 
@@ -545 +545 @@
         }
 
-        return localTerminationCriteriaMet;
-                
+        return localTerminationCriteriaMet;             
 }
 
@@ -552 +551 @@
 inline bool VspTree::GlobalTerminationCriteriaMet(const VspTraversalData &data) const
 {
-        const bool terminationCriteriaMet = (
-                // mOutOfMemory || 
-                (mVspStats.Leaves() >= mMaxViewCells) || 
-        (mGlobalCostMisses >= mTermGlobalCostMissTolerance) 
+        const bool terminationCriteriaMet = (0
+                // || mOutOfMemory
+                || (mVspStats.Leaves() >= mMaxViewCells)
+        || (mGlobalCostMisses >= mTermGlobalCostMissTolerance) 
                 );
 
@@ -674 +673 @@
 
                 // delete old leaf node
-                DEL_PTR(tData.mNode);
+                //DEL_PTR(tData.mNode);
         }
 
@@ -713 +712 @@
                 // finally evaluate statistics for this leaf
                 EvaluateLeafStats(tData);
-        }
-
-        //-- cleanup
-        tData.Clear();
-        
+
+                // detach node so it won't get deleted
+                tData.mNode = NULL;
+        }
+
         return newNode;
 }
@@ -750 +749 @@
         splitCandidate.SetRenderCostDecrease(renderCostDecr);
 
-#if 0
-        const float priority = (float)-data.mDepth;
+#if 1
+        const float priority = (float)-splitCandidate.mParentData.mDepth;
 #else   
 
@@ -1426 +1425 @@
         const float renderCostDecrease = (oldRenderCost - newRenderCost) / viewSpaceVol;
         
-        Debug << "\n==== eval render cost decrease ===" << endl
+        Debug << "\neval vsp render cost decrease" << endl
                   << "back pvs: " << pvsBack << " front pvs " << pvsFront << " total pvs: " << totalPvs << endl 
                   << "back p: " << pBack / viewSpaceVol << " front p " << pFront / viewSpaceVol << " p: " << pOverall / viewSpaceVol << endl
@@ -2630 +2629 @@
 
         //-- prepare view space partition
-
-        // add first candidate for view space partition
+        const float prop = mBoundingBox.GetVolume();
+        
+        // we assume that leaf was already created
         VspLeaf *leaf = new VspLeaf();
         mRoot = leaf;
-
-        const float prop = mBoundingBox.GetVolume();
 
         // first vsp traversal data
@@ -2649 +2647 @@
                 oit_end = leaf->GetViewCell()->GetPvs().mEntries.end();
 
-
         for (oit = leaf->GetViewCell()->GetPvs().mEntries.begin(); oit != oit_end; ++ oit)
         {
@@ -2658 +2655 @@
 
         //-- compute first split candidate
-
         VspSubdivisionCandidate *splitCandidate = new VspSubdivisionCandidate(vData);
     EvalSubdivisionCandidate(*splitCandidate);
@@ -2669 +2665 @@
 
 
-void VspTree::CollectDirtyCandidates(VspSubdivisionCandidate *sc, 
-                                                                         vector<SubdivisionCandidate *> &dirtyList)
-{
-        VspTraversalData &tData = sc->mParentData;
-        VspLeaf *node = tData.mNode;
-        
-        KdLeaf::NewMail();
-
-        RayInfoContainer::const_iterator rit, rit_end = tData.mRays->end();
-
-        // add all kd nodes seen by the rays
-        for (rit = tData.mRays->begin(); rit != rit_end; ++ rit)
-        {
-                VssRay *ray = (*rit).mRay;
-        
-                KdLeaf *leaf = mHierarchyManager->mOspTree->GetLeaf(ray->mOrigin, ray->mOriginNode);
-        
-                if (!leaf->Mailed())
-                {
-                        leaf->Mail();
-                        dirtyList.push_back(leaf->mSubdivisionCandidate);
-                }
-                
-                leaf = mHierarchyManager->mOspTree->GetLeaf(ray->mTermination, ray->mTerminationNode);
-        
-                if (!leaf->Mailed())
-                {
-                        leaf->Mail();
-                        dirtyList.push_back(leaf->mSubdivisionCandidate);
-                }
-        }
-}
-
-
-int VspTree::EvalMaxEventContribution(const VssRay &ray, 
-                                                                          const bool isTermination) const
+void VspTree::CollectDirtyCandidate(const VssRay &ray, 
+                                                                        const bool isTermination,
+                                                                        vector<SubdivisionCandidate *> &dirtyList) const
 {
         Intersectable *obj;
@@ -2712 +2675 @@
         ray.GetSampleData(isTermination, pt, &obj, &node);
 
+        if (!obj) return;
+
+        switch (mHierarchyManager->GetObjectSpaceSubdivisonType())
+        {
+        case HierarchyManager::KD_BASED_OBJ_SUBDIV:
+                {
+                        KdLeaf *leaf = mHierarchyManager->mOspTree->GetLeaf(pt, node);
+
+                        if (!leaf->Mailed())
+                        {
+                                leaf->Mail();
+                                dirtyList.push_back(leaf->mSubdivisionCandidate);
+                        }
+
+                        break;
+                }
+        case HierarchyManager::BV_BASED_OBJ_SUBDIV:
+                {
+                }
+                break;
+        default:
+                break;
+        }
+}
+
+
+void VspTree::CollectDirtyCandidates(VspSubdivisionCandidate *sc, 
+                                                                         vector<SubdivisionCandidate *> &dirtyList)
+{
+        VspTraversalData &tData = sc->mParentData;
+        VspLeaf *node = tData.mNode;
+        
+        KdLeaf::NewMail();
+        BvhLeaf::NewMail();
+
+        RayInfoContainer::const_iterator rit, rit_end = tData.mRays->end();
+
+        // add all kd nodes seen by the rays
+        for (rit = tData.mRays->begin(); rit != rit_end; ++ rit)
+        {
+                VssRay *ray = (*rit).mRay;
+        
+                CollectDirtyCandidate(*ray, true, dirtyList);
+                CollectDirtyCandidate(*ray, false, dirtyList);
+        }
+}
+
+
+int VspTree::EvalMaxEventContribution(const VssRay &ray, 
+                                                                          const bool isTermination) const
+{
+        Intersectable *obj;
+        Vector3 pt;
+        KdNode *node;
+
+        ray.GetSampleData(isTermination, pt, &obj, &node);
+
         if (!obj) 
                 return 0;
@@ -2717 +2737 @@
         int pvs = 0;
 
-        switch ( mHierarchyManager->GetObjectSpaceSubdivisonType())
+        switch (mHierarchyManager->GetObjectSpaceSubdivisonType())
         {
         case HierarchyManager::NO_OBJ_SUBDIV:

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

@@ -342 +342 @@
         {  
         public:
+                
+                /** Returns average ray contribution.
+                */
+                float GetAvgRayContribution() const
+                {
+                        return (float)mPvs / ((float)mRays->size() + Limits::Small);
+                }
+
+
+                VspTraversalData():
+                mNode(NULL),
+                mDepth(0),
+                mRays(NULL),
+                mPvs(0),
+                mProbability(0.0),
+                mMaxCostMisses(0), 
+                mPriority(0)
+                {}
+                
+                VspTraversalData(VspLeaf *node, 
+                                                 const int depth, 
+                                                 RayInfoContainer *rays,
+                                                 const int pvs,
+                                                 const float p,
+                                                 const AxisAlignedBox3 &box):
+                mNode(node), 
+                mDepth(depth), 
+                mRays(rays),
+                mPvs(pvs),
+                mProbability(p),
+                mBoundingBox(box),
+                mMaxCostMisses(0),
+                mPriority(0)
+                {}
+
+                VspTraversalData(const int depth, 
+                                                 RayInfoContainer *rays,
+                                                 const AxisAlignedBox3 &box): 
+                mNode(NULL), 
+                mDepth(depth), 
+                mRays(rays),
+                mPvs(0),
+                mProbability(0),
+                mMaxCostMisses(0),
+                mBoundingBox(box)
+                {}
+
+                /** Returns cost of the traversal data.
+                */
+                float GetCost() const
+                {
+                        return mPriority;
+                }
+
+                /// deletes contents and sets them to NULL
+                void Clear()
+                {
+                        DEL_PTR(mRays);
+                        DEL_PTR(mNode);
+                }
+
                 /// the current node
                 VspLeaf *mNode;
@@ -360 +421 @@
 
                 
-                /** Returns average ray contribution.
-                */
-                float GetAvgRayContribution() const
-                {
-                        return (float)mPvs / ((float)mRays->size() + Limits::Small);
-                }
-
-
-                VspTraversalData():
-                mNode(NULL),
-                mDepth(0),
-                mRays(NULL),
-                mPvs(0),
-                mProbability(0.0),
-                mMaxCostMisses(0), 
-                mPriority(0)
-                {}
-                
-                VspTraversalData(VspLeaf *node, 
-                                                 const int depth, 
-                                                 RayInfoContainer *rays,
-                                                 const int pvs,
-                                                 const float p,
-                                                 const AxisAlignedBox3 &box):
-                mNode(node), 
-                mDepth(depth), 
-                mRays(rays),
-                mPvs(pvs),
-                mProbability(p),
-                mBoundingBox(box),
-                mMaxCostMisses(0),
-                mPriority(0)
-                {}
-
-                VspTraversalData(const int depth, 
-                                                 RayInfoContainer *rays,
-                                                 const AxisAlignedBox3 &box): 
-                mNode(NULL), 
-                mDepth(depth), 
-                mRays(rays),
-                mPvs(0),
-                mProbability(0),
-                mMaxCostMisses(0),
-                mBoundingBox(box)
-                {}
-
-                /** Returns cost of the traversal data.
-                */
-                float GetCost() const
-                {
-                        //cout << mPriority << endl;
-                        return mPriority;
-                }
-
-                /// deletes contents and sets them to NULL
-                void Clear()
-                {
-                        DEL_PTR(mRays);
-                }
-
                 friend bool operator<(const VspTraversalData &a, const VspTraversalData &b)
                 {
@@ -441 +442 @@
                 VspSubdivisionCandidate(const VspTraversalData &tData): mParentData(tData)
                 {};
+
+                ~VspSubdivisionCandidate() { mParentData.Clear(); }
 
                 int Type() const { return VIEW_SPACE; }
@@ -922 +925 @@
         */
         void CollectDirtyCandidates(VspSubdivisionCandidate *sc, vector<SubdivisionCandidate *> &dirtyList);
+
+        void CollectDirtyCandidate(
+                const VssRay &ray, 
+                const bool isTermination,
+                vector<SubdivisionCandidate *> &dirtyList) const;
 
         /** Rays will be clipped to the bounding box.

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

@@ -112 +112 @@
   string result = filename;
 
-  int pos = filename.rfind(a, filename.size()-1);
+  int pos = filename.rfind(a, (int)filename.size() - 1);
   if (pos == filename.size() - a.size()) {
         result.replace(pos, a.size(), b);