Changeset 1421

Timestamp:

09/20/06 18:32:10 (18 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/Lib/Vis/Preprocessing/src

Files:

• BvHierarchy.cpp (modified) (14 diffs)
• Environment.cpp (modified) (1 diff)
• Exporter.cpp (modified) (2 diffs)
• HierarchyManager.cpp (modified) (11 diffs)
• HierarchyManager.h (modified) (4 diffs)
• ObjParser.cpp (modified) (2 diffs)
• Preprocessor.cpp (modified) (5 diffs)
• Preprocessor.h (modified) (1 diff)
• Triangle3.cpp (modified) (2 diffs)
• ViewCellsManager.cpp (modified) (5 diffs)
• ViewCellsManager.h (modified) (1 diff)
• ViewCellsParser.cpp (modified) (4 diffs)
• VspTree.cpp (modified) (9 diffs)
• X3dParser.cpp (modified) (3 diffs)

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

@@ -211 +211 @@
 
 
-        ////////////////////////////////////////////////
+        //////////////////////////////
         //-- max cost ratio for early tree termination
 
@@ -221 +221 @@
 
 
-        /////////////////////////////////////////
+        //////////////////////////////
         //-- factors for subdivision heuristics
 
@@ -239 +239 @@
 
 
-        /////////////////////////////////
+        /////////////
         //-- debug output
 
@@ -294 +294 @@
         AxisAlignedBox3 parentBox = leaf->GetBoundingBox();
 
-        // update stats
-        mBvhStats.nodes += 2; // we have two new leaves
+        // update stats: we have two new leaves
+        mBvhStats.nodes += 2;
 
         if (tData.mDepth > mBvhStats.maxDepth)
@@ -306 +306 @@
         
 
-        ////////////////////////////////
+        //////////////////
         //-- create front and back leaf
 
@@ -336 +336 @@
 
 
-        ///////////////////////////////////////////////////////////////////
+        ////////////////////////////////////////
         //-- fill  front and back traversal data with the new values
 
@@ -393 +393 @@
         if (!LocalTerminationCriteriaMet(tData) && !globalCriteriaMet)
         {       
-                //////////////////////////////////////////
+                //////////////
                 //-- continue subdivision
 
@@ -412 +412 @@
 
 
-                /////////////////////////////////////////
+                ///////////////////////////
                 //-- push the new split candidates on the queue
                 
@@ -487 +487 @@
         const float renderCostDecr = oldRenderCost - newRenderCost;
 
-#ifdef _DEBUG
+//#ifdef _DEBUG
         Debug << "old render cost: " << oldRenderCost << endl;
         Debug << "new render cost: " << newRenderCost << endl;
         Debug << "render cost decrease: " << renderCostDecr << endl;
-#endif
+//#endif
         splitCandidate.SetRenderCostDecrease(renderCostDecr);
 
@@ -522 +522 @@
 inline bool BvHierarchy::GlobalTerminationCriteriaMet(const BvhTraversalData &data) const
 {
-        // matt: TODO
-        return (0
+        const bool terminationCriteriaMet =
+                (0
                 || (mBvhStats.Leaves() >= mTermMaxLeaves)
                 || (mGlobalCostMisses >= mTermGlobalCostMissTolerance)
                 //|| mOutOfMemory 
                 );
+
+        if (0 && terminationCriteriaMet)
+        {
+                Debug << "bvh global termination criteria met:" << endl;
+                Debug << "cost misses: " << mGlobalCostMisses << " " << mTermGlobalCostMissTolerance << endl;
+                Debug << "leaves: " << mBvhStats.Leaves() << " " << mTermMaxLeaves << endl;
+        }
+
+        return terminationCriteriaMet; 
 }
 
@@ -1233 +1242 @@
 void BvHierarchy::PrintSubdivisionStats(const SubdivisionCandidate &sc)
 {
-        const float costDecr = sc.GetRenderCostDecrease();      
+        const float costDecr = 
+                sc.GetRenderCostDecrease();// / mHierarchyManager->GetViewSpaceBox().GetVolume();       
 
         mSubdivisionStats 
-                        << "#Leaves\n" << mBvhStats.Leaves()
+                        << "#Leaves\n" << mBvhStats.Leaves() << endl
                         << "#RenderCostDecrease\n" << costDecr << endl 
                         << "#TotalRenderCost\n" << mTotalCost << endl;
-                        //<< "#AvgRenderCost\n" << avgRenderCost << endl;
 }
 
@@ -1277 +1286 @@
                         return 0.0f;
 
-                /////////////////////////////
+                ////////////////////
                 //-- surface area heuristics
 
@@ -1283 +1292 @@
                 const float area = box.SurfaceArea();
 
-                return (float)objects.size() * area;
+                return (float)objects.size() * area / mHierarchyManager->GetViewSpaceBox().SurfaceArea();
         }
         else
-        {       /////////////////////////////
+        {       ////////////////////
                 //-- render cost heuristics
 
@@ -1647 +1656 @@
         //-- we don't have to sort them here and an binary search 
         //-- for identifying if a object is in a leaf.
-
+        
         mBvhStats.Reset();
         mBvhStats.Start();
+
         mBvhStats.nodes = 1;
-
+        mGlobalCostMisses = 0;
+        
         // store pointer to this tree
         BvhSubdivisionCandidate::sBvHierarchy = this;
-        mBvhStats.nodes = 1;
-        mGlobalCostMisses = 0;
-
+        
         // compute bounding box from objects
         // note: we assume that root was already created

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

@@ -2427 +2427 @@
                                         optFloat,
                                         "hierarchy_term_min_global_cost_ratio=",
-                                        "0.00001");
+                                        "0.9");
 
         RegisterOption("Hierarchy.Termination.globalCostMissTolerance",

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

@@ -267 +267 @@
                 {
                 case Intersectable::TRIANGLE_INTERSECTABLE:
-                        {cout << "y";
+                        {
                                 TriangleIntersectable *ti = dynamic_cast<TriangleIntersectable *>(obj);
                                 polys.push_back(new Polygon3(ti->GetItem()));
@@ -273 +273 @@
                         }
                 case Intersectable::MESH_INSTANCE:
-                        {cout << "x";
+                        {
                                 MeshInstance *mi = dynamic_cast<MeshInstance *>(obj);
                                 ExportMesh(mi->GetMesh());
-                                //polys.push_back(new Polygon3(ti->GetItem()));
-                break;
+                                break;
                         }
                 default:

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

@@ -34 +34 @@
 
 
-HierarchyManager::HierarchyManager(VspTree *vspTree, 
-                                                                   const int objectSpaceSubdivisionType):
+HierarchyManager::HierarchyManager(const int objectSpaceSubdivisionType):
 mObjectSpaceSubdivisionType(objectSpaceSubdivisionType),
-mVspTree(vspTree), 
 mOspTree(NULL), 
 mBvHierarchy(NULL)
@@ -57 +55 @@
 
         // hierarchy manager links view space partition and object space partition
+        mVspTree = new VspTree();
         mVspTree->mHierarchyManager = this;
         
@@ -63 +62 @@
 
 
-HierarchyManager::HierarchyManager(VspTree *vspTree, KdTree *kdTree): 
+HierarchyManager::HierarchyManager(KdTree *kdTree): 
 mObjectSpaceSubdivisionType(KD_BASED_OBJ_SUBDIV),
-mVspTree(vspTree), 
 mBvHierarchy(NULL)
 {
@@ -71 +69 @@
         mOspTree->mVspTree = mVspTree;
 
+        mVspTree = new VspTree();
         mVspTree->mHierarchyManager = this;
 
@@ -120 +119 @@
 {
         DEL_PTR(mOspTree);
-        //DEL_PTR(mVspTree);
+        DEL_PTR(mVspTree);
         DEL_PTR(mBvHierarchy);
 }
@@ -232 +231 @@
 bool HierarchyManager::GlobalTerminationCriteriaMet(SubdivisionCandidate *candidate) const
 {
-        return (0
+        const bool terminationCriteriaMet = 
+                (0
                 || (mHierarchyStats.Leaves() >= mTermMaxLeaves) 
-                //|| (mGlobalCostMisses >= mTermGlobalCostMissTolerance)
-                ||      candidate->GlobalTerminationCriteriaMet()
+                || (mGlobalCostMisses >= mTermGlobalCostMissTolerance)
+                ||(candidate->GlobalTerminationCriteriaMet())
                 );
+
+        if (0 && terminationCriteriaMet)
+        {
+                Debug << "hierarchy global termination criteria met:" << endl;
+                Debug << "leaves: " << mHierarchyStats.Leaves() << " " << mTermMaxLeaves << endl;
+                Debug << "cost misses: " << mGlobalCostMisses << " " << mTermGlobalCostMissTolerance << endl;
+        }
+        return terminationCriteriaMet;
 }
 
@@ -306 +314 @@
                 mVspTree->PrepareConstruction(sampleRays, *viewSpaceRays);
 
+        mTotalCost = mVspTree->mTotalCost;
+        Debug << "\nreseting cost, new total cost: " << mTotalCost << endl;
+
         mTQueue.Push(vsc);
 }
@@ -328 +339 @@
 
 {
-        cout << "starting bv hierarchy construction ... " << endl;
+        const long startTime = GetTime();
+
+        cout << "preparing bv hierarchy construction ... " << endl;
         mBvHierarchy->CreateRoot(objects);
 
@@ -339 +352 @@
 
     mTQueue.Push(sc);
+        cout << "finished bv hierarchy preparation in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
 }
 
@@ -357 +371 @@
 
         mTotalCost = mOspTree->mTotalCost;
-        Debug << "reseting cost, new total cost: " << mTotalCost << endl;
+        Debug << "\nreseting cost, new total cost: " << mTotalCost << endl;
         
     mTQueue.Push(osc);
@@ -739 +753 @@
 
 
-void HierarchyManager::PrintHierarchyStatistics(ofstream &stream) const
+void HierarchyManager::PrintHierarchyStatistics(ostream &stream) const
 {
         stream << mHierarchyStats << endl;
-
         stream << "\nview space:" << endl << endl;
         stream << mVspTree->GetStatistics() << endl;

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

@@ -139 +139 @@
 
 public:
-        /** Constructor with the object space hierarchy type as argument.
-        */
-        HierarchyManager(VspTree *vspTree, const int objectSpaceHierarchyType);
+        /** Constructor with the view space partition tree and
+                the object space hierarchy type as argument.
+        */
+        HierarchyManager(const int objectSpaceHierarchyType);
         /** Hack: OspTree will copy the content from this kd tree.
                 Only view space hierarchy will be constructed.
         */
-        HierarchyManager(VspTree *vspTree, KdTree *kdTree);
-
+        HierarchyManager(KdTree *kdTree);
+
+        /** Deletes space partition and view space partition.
+        */
         ~HierarchyManager();
 
@@ -196 +199 @@
                 float &contribution) const;
 
-        void PrintHierarchyStatistics(ofstream &stream) const;
-
+        /** Print out statistics.
+        */
+        void PrintHierarchyStatistics(ostream &stream) const;
+
+        /** Returns the view space partition tree.
+        */
         VspTree *GetVspTree();
 
+        /** Returns view space bounding box.
+        */
         AxisAlignedBox3 GetViewSpaceBox() const;
+        /** Returns object space bounding box.
+        */
         AxisAlignedBox3 GetObjectSpaceBox() const;
 
+        /** Exports object space hierarchy for visualization.
+        */
         void ExportObjectSpaceHierarchy(
                 Exporter *exporter, 
@@ -209 +222 @@
                 const bool exportBounds = true) const;
 
-
+        /** Returns intersectable pierced by this ray.
+        */
         Intersectable *GetIntersectable(
                 const VssRay &ray, 
@@ -216 +230 @@
         friend ostream &operator<<(ostream &s, const HierarchyManager &hm) 
         {
-                hm.mHierarchyStats.Print(s);
+                hm.PrintHierarchyStatistics(s);
                 return s;
         } 
+
 
 protected:

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

@@ -211 +211 @@
                         {
                                 cout << "f";
-#if CONNECT_SEQUENTIAL_FACES
-                                Face *face = LoadFace(str, vertices, hashTable);
-                                if (!face) break;
-        
-                                faces.push_back(face);
-
-                                if (faces.size() >= nMaxFaces)
+
+                                if (loadMeshes)
                                 {
-                                        ProcessMesh(faces, hashTable, root, parents);
+                                        Face *face = LoadFace(str, vertices, hashTable);
+                                        if (!face) break;
+        
+                                        faces.push_back(face);
+
+                                        if (faces.size() >= nMaxFaces)
+                                        {
+                                                ProcessMesh(faces, hashTable, root, parents);
+                                        }
                                 }
-#else
-                                Triangle3 triangle = LoadTriangle(str, vertices, hashTable);
+                                else
+                                {
+                                        Triangle3 triangle = LoadTriangle(str, vertices, hashTable);
                                 
-                                TriangleIntersectable *obj = new TriangleIntersectable(triangle);
-                                root->mGeometry.push_back(obj);
-
-                                // matt: we don't really need to keep an additional data structure
-                                // if working with triangles => remove this
-                                if (parents) 
-                                {
-                                        FaceParentInfo info(obj, 0);
-                                        parents->push_back(info);
+                                        TriangleIntersectable *obj = new TriangleIntersectable(triangle);
+                                        root->mGeometry.push_back(obj);
+
+                                        // matt: we don't really need to keep an additional data structure
+                                        // if working with triangles => remove this
+                                        if (parents) 
+                                        {
+                                                FaceParentInfo info(obj, 0);
+                                                parents->push_back(info);
+                                        }
                                 }
-#endif
                                 break;
                         }   // end face
@@ -242 +246 @@
         }
 
-#if CONNECT_SEQUENTIAL_FACES
-        // there could be faces remaining
-        if (!faces.empty())
-        {       
-                ProcessMesh(faces, hashTable, root, parents);
-        }
-#endif
+        if (loadMeshes)
+        {
+                // there could be faces remaining
+                if (!faces.empty())
+                {       
+                        ProcessMesh(faces, hashTable, root, parents);
+                }
+        }
+
         // reset tables
         hashTable.clear();

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

@@ -131 +131 @@
 mBspTree(NULL),
 mVspBspTree(NULL),
-mVspTree(NULL),
 mHierarchyManager(NULL),
 mViewCellsManager(NULL),
@@ -185 +184 @@
         cout << "Deleting kd tree...\n";
         DEL_PTR(mKdTree);
-        cout << "done.\n";
-
-        cout << "Deleting vsp tree...\n";
-        DEL_PTR(mVspTree);
         cout << "done.\n";
 
@@ -505 +500 @@
                 const bool ishack = false;
                 if (ishack)
-                        hierarchyManager = new HierarchyManager(mVspTree, mKdTree);
+                        hierarchyManager = new HierarchyManager(mKdTree);
                 else
-                        hierarchyManager = new HierarchyManager(mVspTree, HierarchyManager::KD_BASED_OBJ_SUBDIV);
+                        hierarchyManager = new HierarchyManager(HierarchyManager::KD_BASED_OBJ_SUBDIV);
         }
         else if (strcmp(name, "bvh") == 0)
         {
                 Debug << "hierarchy manager: bvh" << endl;
-                hierarchyManager = new HierarchyManager(mVspTree, HierarchyManager::BV_BASED_OBJ_SUBDIV);
+                hierarchyManager = new HierarchyManager(HierarchyManager::BV_BASED_OBJ_SUBDIV);
         }
         else // only view space partition
         {
                 Debug << "hierarchy manager: obj" << endl;
-                hierarchyManager = new HierarchyManager(mVspTree, HierarchyManager::NO_OBJ_SUBDIV);
+                hierarchyManager = new HierarchyManager(HierarchyManager::NO_OBJ_SUBDIV);
         }
 
@@ -548 +543 @@
         else if (strcmp(name, "vspOspTree") == 0)
         {
-                mVspTree = new VspTree();
+                Debug << "view cell type: VspOsp" << endl;
                 char buf[100];          
                 Environment::GetSingleton()->GetStringValue("Hierarchy.type", buf);     
@@ -555 +550 @@
                 mViewCellsManager = new VspOspViewCellsManager(vcTree, mHierarchyManager);
         }
-        else if (strcmp(name, "sceneDependent") == 0)
+        else if (strcmp(name, "sceneDependent") == 0) //TODO
         {
                 Debug << "view cell type: Bsp" << endl;
-
-                //TODO
+                
                 mBspTree = new BspTree();
                 mViewCellsManager = new BspViewCellsManager(vcTree, mBspTree);

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

@@ -199 +199 @@
   /// View space partition bsp tree
   VspBspTree *mVspBspTree;
-  // view space partition tree
-  VspTree *mVspTree;
+  /// Hierarchy manager handling view space and object space partition
   HierarchyManager *mHierarchyManager;
   /// BSP tree representing the viewcells

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

@@ -100 +100 @@
   
         const Vector3 pt = ray.GetLoc() + t * dir; 
-
+#if _DEBUG
         if (!pt.CheckValidity())
         {
@@ -106 +106 @@
                 cout << "v: " << pt << " t: " << t << " a: " << a << " b: " << b << " n: " << normal << endl;
         }
-
+#endif
         const Vector3 w = pt - mVertices[1];
 

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

@@ -4781 +4781 @@
         GetRaySets(rays, mInitialSamples, constructionRays, &savedRays);
 
-        Debug << "initial rays: " << (int)constructionRays.size() << endl;
+        Debug << "initial rays used for construction: " << (int)constructionRays.size() << endl;
         Debug << "saved rays: " << (int)savedRays.size() << endl;
 
@@ -4794 +4794 @@
 
         // print subdivision statistics
-        Debug << endl << endl << mHierarchyManager << endl;
+        Debug << endl << endl << *mHierarchyManager << endl;
         //mHierarchyManager->PrintHierarchyStatistics(Debug);
 
@@ -5583 +5583 @@
 
         cout << "reseting pvs ... ";
-                
         const bool startFromZero = true;
-
 
         // reset pvs and start over from zero
@@ -5632 +5630 @@
         mViewCellsTree->CollectLeaves(mViewCellsTree->GetRoot(), leaves);
         float rc = 0;
+
         ViewCellContainer::const_iterator vit, vit_end = leaves.end();
+        
         for (vit = leaves.begin(); vit != vit_end; ++ vit)
         {
@@ -5639 +5639 @@
                 float vol = vc->GetVolume();
                 rc += pvs * vol;
-
         }
 

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

@@ -979 +979 @@
 };
 
-#define TEST_EVALUATION 1
+#define TEST_EVALUATION 0
 
 /**

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

@@ -621 +621 @@
 
                                 mHierarchyManager = 
-                                        new HierarchyManager(mVspTree, HierarchyManager::KD_BASED_OBJ_SUBDIV);
+                                        new HierarchyManager(HierarchyManager::KD_BASED_OBJ_SUBDIV);
+
+                                DEL_PTR(mHierarchyManager->mVspTree);
+                                mHierarchyManager->mVspTree = mVspTree;
 
                                 mObjectSpaceHierarchyType = OSP;
@@ -642 +645 @@
                                 mObjectSpaceHierarchyType = BVH;
                                 mHierarchyManager = 
-                                        new HierarchyManager(mVspTree, HierarchyManager::BV_BASED_OBJ_SUBDIV);
+                                        new HierarchyManager(HierarchyManager::BV_BASED_OBJ_SUBDIV);
+
+                                DEL_PTR(mHierarchyManager->mVspTree);
+                                mHierarchyManager->mVspTree = mVspTree;
                         }
                 }
@@ -905 +911 @@
                 }
         }
-        //cout << "\nview space box: " << mViewSpaceBox << endl;
-}
-
-
-void ViewCellsParseHandlers::CreateViewCellsManager(/*const char *name*/)
+}
+
+
+void ViewCellsParseHandlers::CreateViewCellsManager()
 {
         if (mViewSpaceHierarchyType == BSP)
@@ -920 +925 @@
         {
                 Debug << "creating view cells manager: VspOsp" << endl;
-
                 // hack
                 mViewCellsManager = new VspOspViewCellsManager(mViewCellsTree, mHierarchyManager);

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

@@ -359 +359 @@
 
 
+
 /*************************************************************************/
 /*                       class VspTree implementation                    */
@@ -367 +368 @@
 mRoot(NULL),
 mOutOfBoundsCell(NULL),
-mStoreRays(true),
+mStoreRays(false),
 mTimeStamp(1),
 mHierarchyManager(NULL)
@@ -566 +567 @@
         if (0 && terminationCriteriaMet)
         {
-                Debug << "globlal termination criteria met:" << endl;
+                Debug << "vsp global termination criteria met:" << endl;
                 Debug << "cost misses: " << mGlobalCostMisses << " " << mTermGlobalCostMissTolerance << endl;
                 Debug << "leaves: " << mVspStats.Leaves() << " " <<  mMaxViewCells << endl;
@@ -696 +697 @@
                 /////////////
                 //-- store pvs optained from rays
+
                 AddSamplesToPvs(leaf, *tData.mRays, sampCon, conSamp);
 
@@ -1295 +1297 @@
         }
         
-        
+        /////////       
         //-- compute cost
 
@@ -1479 +1481 @@
         // the render cost decrase for this split
         const float renderCostDecrease = (oldRenderCost - newRenderCost) / viewSpaceVol;
-#ifdef _DEBUG
-        Debug << "\neval vsp render cost decrease" << endl
+
+//#ifdef _DEBUG
+        Debug << "\nvsp 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
                   << "old rc: " << normalizedOldRenderCost << " new rc: " << newRenderCost / viewSpaceVol << endl
                   << "render cost decrease: " << renderCostDecrease << endl;
-#endif
+//#endif
         return renderCostDecrease;
 }
@@ -2681 +2684 @@
 
         const int pvsSize = EvalPvsSize(rays);
-        //Debug <<  "pvs size: " << (int)pvsSize << endl;
-        //Debug <<  "rays size: " << (int)rays.size() << endl;
-
+        
+
+        //////////
         //-- prepare view space partition
+
         const float prop = mBoundingBox.GetVolume();
         
@@ -2696 +2700 @@
         // create first view cell
         CreateViewCell(vData, false);
-                
+
 #if WORK_WITH_VIEWCELL_PVS
         // add first view cell to all the objects view cell pvs
@@ -2709 +2713 @@
 #endif
 
-        //-- compute first split candidate
+        //////////////
+        //-- create the first split candidate
 
         VspSubdivisionCandidate *splitCandidate = new VspSubdivisionCandidate(vData);

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

@@ -234 +234 @@
                 //-- load data as single triangles instead of whole meshes
 
-                //cout << "m";  
+                cout << "m";    
                 Mesh tempMesh(*mCurrentMesh);
                 ApplyTransformations(mTransformations, &tempMesh);
@@ -590 +590 @@
  
   if (element == "Shape") {
-          //cout << "+"; 
+          cout << "+"; 
 
           // reset current shape values
@@ -603 +603 @@
   }
 
-  // todo
+  // todo: materials don't work proberly yet
   if (element == "Material") {
           StartMaterial(attributes);