Changeset 1415 for GTP/trunk/Lib

Timestamp:

09/18/06 18:57:34 (18 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/Lib/Vis/Preprocessing/src

Files:

• AxisAlignedBox3.cpp (modified) (2 diffs)
• AxisAlignedBox3.h (modified) (2 diffs)
• BvHierarchy.cpp (modified) (2 diffs)
• Environment.cpp (modified) (1 diff)
• Exporter.cpp (modified) (10 diffs)
• Exporter.h (modified) (3 diffs)
• HierarchyManager.cpp (modified) (10 diffs)
• HierarchyManager.h (modified) (1 diff)
• KdTree.cpp (modified) (1 diff)
• OspTree.cpp (modified) (1 diff)
• Preprocessor.cpp (modified) (3 diffs)
• Preprocessor.h (modified) (1 diff)
• RssPreprocessor.cpp (modified) (1 diff)
• ViewCellsManager.cpp (modified) (27 diffs)
• VspTree.cpp (modified) (5 diffs)
• X3dParser.cpp (modified) (5 diffs)
• main.cpp (modified) (3 diffs)

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

@@ -2129 +2129 @@
                                                         AxisAlignedBox3 &back) const
 {
-        if ( (value >= mMin[axis]) && (value <= mMax[axis]) )
+        if ((value >= mMin[axis]) && (value <= mMax[axis]))
         {
                 front.mMin = mMin; front.mMax = mMax;
@@ -2139 +2139 @@
 }
 
-
-}
+ 
+void AxisAlignedBox3::Scale(const float scale) 
+{
+        Vector3 newSize = Size()*(scale*0.5f);
+        Vector3 center = Center();
+        mMin = center - newSize;
+        mMax = center + newSize;
+}
+
+
+void AxisAlignedBox3::Scale(const Vector3 &scale) 
+{
+        Vector3 newSize = Size()*(scale*0.5f);
+        Vector3 center = Center();
+        mMin = center - newSize;
+        mMax = center + newSize;
+}
+
+
+void AxisAlignedBox3::Translate(const Vector3 &shift) 
+{
+         mMin += shift;
+         mMax += shift;
+}
+
+
+}

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

@@ -72 +72 @@
     mMin -= v;
   }
-
 
   void SetMin(const Vector3 &v) {
@@ -167 +166 @@
   /** Scales the box with the factor.
   */
-  void Scale(const float scale) {
-        Vector3 newSize = Size()*(scale*0.5f);
-        Vector3 center = Center();
-        mMin = center - newSize;
-        mMax = center + newSize;
-  }
-
-  void Scale(const Vector3 &scale) {
-        Vector3 newSize = Size()*(scale*0.5f);
-        Vector3 center = Center();
-        mMin = center - newSize;
-        mMax = center + newSize;
-  }
-
+  void Scale(const float scale);
+
+  void Scale(const Vector3 &scale);
+        
   /** Translates the box with the factor.
   */
-  void Translate(const Vector3 &shift) {
-        mMin += shift;
-        mMax += shift;
-  }
+  void Translate(const Vector3 &shift);
 
   /** Returns the square of the minimal and maximal distance to 

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

@@ -608 +608 @@
         }
 
+#if 0
         cout << "depth: " << data.mDepth << " objects: " << (int)leaf->mObjects.size() 
                  << " rays: " << data.mNumRays << " rays / objects " 
                  << (float)data.mNumRays / (float)leaf->mObjects.size() << endl;
+#endif
 }
 
@@ -1423 +1425 @@
         ViewCellContainer viewCells;
         CollectViewCells(node->mObjects, viewCells);
+        if (0) cout << "collected " << (int)viewCells.size() << " dirty candidates" << endl;
 
         // split candidates handling 
         // these view cells  are thrown into dirty list
         ViewCellContainer::const_iterator vit, vit_end = viewCells.end();
-
-        Debug << "collecting " << (int)viewCells.size() << " dirty candidates" << endl;
 
         for (vit = viewCells.begin(); vit != vit_end; ++ vit)

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

@@ -1748 +1748 @@
                                         "false");
 
-
-
-        /************************************************************************************/
-        /*                   VSS Preprocessor cells related options                         */
-        /************************************************************************************/
+        RegisterOption("Preprocessor.kdTreeFilename", 
+                                        optString,
+                                        "preprocessor_kd_tree_filename=",
+                                        "vienna_kdtree.bin.gz");
+        
+
+        /*************************************************************************/
+        /*             VSS Preprocessor cells related options                    */
+        /*************************************************************************/
 
         RegisterOption("VssTree.maxDepth", optInt, "kd_depth=", "12");

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

@@ -33 +33 @@
 
 
-bool Exporter::ExportOspTree(const OspTree &ospTree, const int maxPvs)
+bool Exporter::ExportOspTree(const OspTree &ospTree, 
+                                                         const int maxPvs
+                                                         )
 {
         vector<KdLeaf *> leaves;
         ospTree.CollectLeaves(leaves);
-
         mUseForcedMaterial = true;
 
@@ -69 +70 @@
                         SetForcedMaterial(RandomMaterial());
                 }
-
                 if (0) ExportGeometry(leaf->mObjects);  
         }
@@ -80 +80 @@
 {
         KdNode *node = kdObj.GetItem();
-        
         Intersectable::NewMail();
 
@@ -106 +105 @@
 
 bool Exporter::ExportBvHierarchy(const BvHierarchy &bvHierarchy, 
-                                                                 const int maxPvs)
+                                                                 const int maxPvs,
+                                                                 AxisAlignedBox3 *box)
 {
         vector<BvhLeaf *> leaves;
@@ -112 +112 @@
 
         mUseForcedMaterial = true;
-
         vector<BvhLeaf *>::const_iterator it, it_end = leaves.end();
 
@@ -126 +125 @@
                         continue;
 
+                if (box && !Overlap(*box, leaf->GetBoundingBox()))
+                        continue;
+
                 SetWireframe();
                 SetForcedMaterial(white);
@@ -223 +225 @@
 
 void Exporter::ExportGeometry(const ObjectContainer &objects, 
-                                                          const bool exportSingleMesh)
+                                                          const bool exportSingleMesh,
+                                                          AxisAlignedBox3 *bbox)
 {
         ObjectContainer::const_iterator oit, oit_end = objects.end();
@@ -231 +234 @@
                 for (oit = objects.begin(); oit != oit_end; ++ oit)
                 {
-                        if (0) SetForcedMaterial(RandomMaterial());
-                        ExportIntersectable(*oit);
+                        if (bbox && Overlap(*bbox, (*oit)->GetBox()))
+                        {
+                                if (0) SetForcedMaterial(RandomMaterial());
+                                ExportIntersectable(*oit);
+                        }
                 }
 
@@ -238 +244 @@
         }
 
+        
+        ///////////////////////////////////////////
         //-- all objects exported as one mesh
         //-- hack: currently works only for triangles
+
         PolygonContainer polys;
 
@@ -245 +254 @@
         {
                 Intersectable *obj = *oit;
+
+                if (bbox && !Overlap(*bbox, (*oit)->GetBox()))
+                        continue;
+
                 switch (obj->Type())
                 {

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

@@ -73 +73 @@
 
   virtual bool
-  ExportOspTree(const OspTree &tree, const int maxPvs);// = 0;
-
-//    virtual bool
-//    ExportRays(const vector<Ray> &rays,
-//           const float length=1000,
-//           const RgbColor &color = RgbColor(1,1,1)
-//           ) = 0;
+  ExportOspTree(const OspTree &tree, const int maxPvs);
   
   virtual bool
@@ -123 +117 @@
 
   virtual void
-  ExportGeometry(const ObjectContainer &objects, const bool exportSingleMesh = false);
+  ExportGeometry(const ObjectContainer &objects, const bool exportSingleMesh = false, AxisAlignedBox3 *bbox = NULL);
 
   virtual void
@@ -153 +147 @@
 
   void ExportKdIntersectable(const KdIntersectable &kdObj);
-  bool ExportBvHierarchy(const BvHierarchy &bvHierarchy, const int maxPvs);
+  bool ExportBvHierarchy(const BvHierarchy &bvHierarchy, const int maxPvs, AxisAlignedBox3 *box = NULL);
 
   virtual void ExportMeshInstance(MeshInstance *mi);

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

@@ -309 +309 @@
 {
         cout << "starting bv hierarchy construction ... " << endl;
-
         mBvHierarchy->CreateRoot(objects);
 
@@ -317 +316 @@
 
         mTotalCost = mBvHierarchy->mTotalCost;
-        Debug << "reseting cost, new total cost: " << mTotalCost << endl;
+        Debug << "\nreseting cost, new total cost: " << mTotalCost << endl;
 
     mTQueue.Push(sc);
@@ -373 +372 @@
                 }
         }
+
         return true;//!globalTerminationCriteriaMet;
 }
@@ -458 +458 @@
                 }
                 
-                ///////////////////////////
+                ///////////////////
                 //-- subdivide leaf node
+
                 if (ApplySubdivisionCandidate(mCurrentCandidate))
                 {
-                        cout << "subdividing candidate " << ++ i << " of type " << mCurrentCandidate->Type() << endl;
+                        cout << mCurrentCandidate->Type() << " ";
+                        if (0) cout << "subdividing candidate " << ++ i << " of type " << mCurrentCandidate->Type() << endl;
                         mHierarchyStats.nodes += 2;
 
@@ -474 +476 @@
 
                 // we use objects for evaluating vsp tree construction until 
-                // a certain depth once a certain depth existiert ....
+                // a certain depth once a certain depth existiert ...
                 if (StartObjectSpaceSubdivision())
                 {
                         mObjectSpaceSubdivisionType = mSavedObjectSpaceSubdivisionType;
 
-                        cout << "starting object space subdivision at depth " 
+                        cout << "\nstarting object space subdivision at depth " 
                                  << mVspTree->mVspStats.maxDepth << " (" 
                                  << mMinDepthForObjectSpaceSubdivion << ") " << endl;
@@ -494 +496 @@
                         mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType;
 
-                        cout << "starting view space subdivision at depth " 
+                        cout << "\nstarting view space subdivision at depth " 
                                  << GetObjectSpaceSubdivisionDepth() << " (" 
                                  << mMinDepthForViewSpaceSubdivion << ") " << endl;
@@ -608 +610 @@
         vector<SubdivisionCandidate *> dirtyList;
         CollectDirtyCandidates(dirtyList);
-        cout << "repairing " << (int)dirtyList.size() << " candidates ... ";
-        
+        if (0) cout << "repairing " << (int)dirtyList.size() << " candidates ... ";
+        
+        /////////////////////////////////
         //-- reevaluate the dirty list
+
         SubdivisionCandidateContainer::const_iterator sit, sit_end = dirtyList.end();
         
@@ -638 +642 @@
         mHierarchyStats.repairTime += timeDiff;
 
-        cout << "finished in " << timeDiff * 1e-3f << " secs" << endl;
+        if (0) cout << "finished in " << timeDiff * 1e-3f << " secs" << endl;
 }
 
@@ -753 +757 @@
         case BV_BASED_OBJ_SUBDIV:
                 {
-                        ExportBvHierarchy(exporter, objects);
+                        AxisAlignedBox3 bbox = mBvHierarchy->GetBoundingBox();
+                        bbox.Scale(Vector3(0.5, 1, 0.5));
+                        
+                        ExportBvHierarchy(exporter, objects, &bbox);
                         break;
                 }
@@ -763 +770 @@
 
 void HierarchyManager::ExportBvHierarchy(Exporter *exporter, 
-                                                                                 const ObjectContainer &objects) const
+                                                                                 const ObjectContainer &objects,
+                                                                                 AxisAlignedBox3 *bbox) const
 {
         exporter->SetWireframe();
-        exporter->ExportBvHierarchy(*mBvHierarchy, 0);
+        exporter->ExportBvHierarchy(*mBvHierarchy, 0, bbox);
 }
 

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

@@ -251 +251 @@
                 
         void ExportOspTree(Exporter *exporter, const ObjectContainer &objects) const;
-        void ExportBvHierarchy(Exporter *exporter, const ObjectContainer &objects) const;
+
+        void ExportBvHierarchy(
+                Exporter *exporter, 
+                const ObjectContainer &objects, 
+                AxisAlignedBox3 *box) const;
 
         void PrepareBvHierarchy(

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

@@ -1380 +1380 @@
                 {
                         EvaluateLeafStats(tData);
-                        cout << "l";
-                }
-        }
+                        //cout << "l";
+                }
+        }
+
         Debug << mStat << endl;
 

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

@@ -155 +155 @@
         }
 
-        // if not using kd tree root, delete tree (otherwise mKdTree has to do the job)
+        // delete hierarchy only if not using the hierarchy from 
+        // some other kd tree (otherwise the other kd tree has to do the job)
         if (!mCopyFromKdTree)
                 DEL_PTR(mRoot);

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

@@ -154 +154 @@
         char buffer[256];
         Environment::GetSingleton()->GetStringValue("Preprocessor.visibilityFile",  buffer);
+    
         mVisibilityFileName = buffer;
         Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilityFilter", mApplyVisibilityFilter );
@@ -372 +373 @@
   mSceneGraph->CollectObjects(&root->mObjects);
   
-  long startTime = GetTime();
+  const long startTime = GetTime();
   cout << "building kd tree ... " << endl;
 
   mKdTree->Construct();
 
-  cout << "construction finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs " << endl;
+  cout << "finished kd tree construction in " << TimeDiff(startTime, GetTime()) * 1e-3 
+           << " secs " << endl;
 
   return true;
 }
+
 
 void
@@ -787 +790 @@
 bool Preprocessor::InitRayCast(const string externKdTree)
 {
+        bool loadKdTree, exportKdTree;
+
+        Environment::GetSingleton()->GetBoolValue("Preprocessor.loadKdTree", loadKdTree);
+        Environment::GetSingleton()->GetBoolValue("Preprocessor.exportKdTree", exportKdTree);
+
+        char kdtreename[100];
+        Environment::GetSingleton()->GetStringValue("Preprocessor.kdTreeFilename", kdtreename);
+
+        
+        if (!loadKdTree)
+        {
+                /////////////////
+                //-- build new kd tree from scene geometry
+
+                BuildKdTree();
+                KdTreeStatistics(cout);
+        }
+        else
+        {
+                const long startTime = GetTime();
+                cout << "loading kd tree file " << kdtreename << " ... ";
+
+                if (!LoadKdTree(kdtreename))
+                {
+                        cout << "error loading kd tree with filename " << kdtreename << endl;
+                        return false;
+                }
+                cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+
+                if (0)
+                {
+                        Exporter *exporter = Exporter::GetExporter("dummykd.x3d");
+                        
+                        if (exporter)
+                        {
+                                exporter->ExportKdTree(*mKdTree, true);
+                                delete exporter;
+                        }
+                }
+        }
+
+        if (exportKdTree)
+        {
+                const long startTime = GetTime();
+                cout << "exporting kd tree ... ";
+                if (!ExportKdTree(kdtreename))
+                {
+                        cout << " error exporting kd tree with filename " << kdtreename << endl;
+                }
+                else
+                {
+                        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+                }
+        }
+
         switch (mRayCastMethod) // use intel ray tracing
         {

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

@@ -280 +280 @@
   /////////////////////////
 
-        int mRayCastMethod;
+  int mRayCastMethod;
   /// samples used for construction of the BSP view cells tree.
   int mBspConstructionSamples;

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

@@ -88 +88 @@
 
 
-#if 0 //matt: this moved up to preprocessor
+#if 0 //matt: this moved up into preprocessor
 int
 RssPreprocessor::CastRay(

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

@@ -1946 +1946 @@
 }
 
-
+// matt: todo
 void ViewCellsManager::ExportViewCellsForViz(Exporter *exporter) const
 {
@@ -2640 +2640 @@
                 mViewCellsTree->SetRoot(root);
 
-                // compute pvs
+                // recompute pvs in the whole hierarchy
                 ObjectPvs pvs;
                 UpdatePvsForEvaluation(root, pvs);
         }
+
+        cout << "finished" << endl;
+        cout << "merged view cells in "
+                 << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+
+        Debug << "Postprocessing: Merged view cells in "
+                << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl << endl;
+
+        
+        /////////////////////////////////////////
+        //-- visualization and statistics
 
         // export statistics after merge
@@ -2653 +2664 @@
         }
 
-        //-- stats and visualizations
-        cout << "finished" << endl;
-        cout << "merged view cells in "
-                 << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-
-        Debug << "Postprocessing: Merged view cells in "
-                << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl << endl;
-        
-
-        //-- visualization and statistics
-    // reset view cells and stats
-        ResetViewCells();
+        ResetViewCells(); // reset view cells
         Debug << "\nView cells after merge:\n" << mCurrentViewCellsStats << endl;
 
@@ -2763 +2763 @@
         {
                 mColorCode = 1; // hack color code
-                Exporter *exporter = Exporter::GetExporter("final_view_cells.x3d");
+                Exporter *exporter = Exporter::GetExporter("final_view_cells.wrl");
         
                 cout << "exporting view cells after merge (pvs size) ... ";     
@@ -3815 +3815 @@
         SimulationStatistics ss;
         dynamic_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
-    Debug << "render time before refine\n" << ss << endl;
+    Debug << "render time before refine\n\n" << ss << endl;
 
         const long startTime = GetTime();
@@ -3898 +3898 @@
         //-- render simulation after merge + refine
 
-        cout << "\nview cells partition render time before compress";
+        cout << "\nview cells partition render time before compress" << endl << endl;;
         dynamic_cast<RenderSimulator *>(mRenderer)->RenderScene();
         SimulationStatistics ss;
@@ -4449 +4449 @@
         //    find view cells associated with the samples
         //    store the sample pvs with the pvs associated with the view cell
+        //
         // for each view cell:
         //    compute difference point sampled pvs - view cell pvs
@@ -4490 +4491 @@
                 m.mDiffuseColor.b = 1.0f;
                 //exporter->SetForcedMaterial(m);
-
-//              ExportViewCellGeometry(exporter, vc, mClipPlane);
-
-/*      // counting the pvss
-        for (rit = samples.begin(); rit != rit_end; ++ rit)
-        {
-                RenderCostSample sample = *rit;
-
-                ViewCell *vc = GetViewCell(sample.mPosition);
-                
-                AxisAlignedBox3 box(sample.mPosition - Vector3(1, 1, 1), sample.mPosition + Vector3(1, 1, 1));
-                Mesh *hMesh = CreateMeshFromBox(box);
-                
-                DEL_PTR(hMesh);
-
-*/
+                //ExportViewCellGeometry(exporter, vc, mClipPlane);
+
+                /*      // counting the pvss
+                for (rit = samples.begin(); rit != rit_end; ++ rit)
+                {
+                        RenderCostSample sample = *rit;
+                        ViewCell *vc = GetViewCell(sample.mPosition);
+
+                        AxisAlignedBox3 box(sample.mPosition - Vector3(1, 1, 1), sample.mPosition + Vector3(1, 1, 1));
+                        Mesh *hMesh = CreateMeshFromBox(box);
+
+                        DEL_PTR(hMesh);
+                }
+                */
         }
 }
@@ -4801 +4800 @@
 
         // print subdivision statistics
+        Debug << endl << endl;
         mHierarchyManager->PrintHierarchyStatistics(Debug);
 
@@ -4815 +4815 @@
 
         const long startTime = GetTime();
-
         cout << "Computing remaining ray contributions ... ";
 
@@ -4822 +4821 @@
                 ComputeSampleContributions(savedRays, true, false);
 
-        cout << "finished" << endl;
-
-        Debug << "Computed remaining ray contribution in " << TimeDiff(startTime, GetTime()) * 1e-3
+        Debug << "finished computing remaining ray contribution in " << TimeDiff(startTime, GetTime()) * 1e-3
                   << " secs" << endl;
 
-        cout << "construction finished" << endl;
-
-        // real meshes are contructed at this stage
         if (0)
         {
+                // real meshes are constructed at this stage
                 cout << "finalizing view cells ... ";
                 FinalizeViewCells(true);
@@ -4908 +4903 @@
         //-- render simulation after merge + refine
 
-        cout << "\nview cells partition render time before compress";
+        cout << "\nview cells partition render time before compress" << endl << endl;
         dynamic_cast<RenderSimulator *>(mRenderer)->RenderScene();
         SimulationStatistics ss;
@@ -5028 +5023 @@
         
         if (clipPlane)
+        {
                 plane = clipPlane->GetPlane();
+        }
+
+        AxisAlignedBox3 bbox = GetViewSpaceBox();
+        bbox.Scale(Vector3(0.5, 1, 0.5));                       
 
         for (it = leaves.begin(); it != it_end; ++ it)
@@ -5037 +5037 @@
                 const AxisAlignedBox3 box = mHierarchyManager->GetVspTree()->GetBoundingBox(vspVc->mLeaf);
                 
+                if (!Overlap(box, bbox))
+                        continue;
+
                 if (clipPlane)
                 {
@@ -5081 +5084 @@
         if (1) 
         {       
+                /////////////////////////////
                 //-- export final view cells
 
-                // hack pvs
+                // hack color code (show pvs size)
                 const int savedColorCode = mColorCode;
                 mColorCode = 0;
@@ -5091 +5095 @@
                 if (exporter)
                 {
-                        cout << "exporting view cells after post process ... ";
+                        const long starttime = GetTime();
+                        cout << "exporting final view cells (after initial construction + post process) ... ";
 
                         if (mExportGeometry)
@@ -5113 +5118 @@
                         delete exporter;
 
-                        cout << "finished" << endl;
+                        cout << "finished in " << TimeDiff(starttime, GetTime()) * 1e-3f << " secs" << endl;
                 }
 
@@ -5126 +5131 @@
                 if (exporter)
                 {
+                        const long starttime = GetTime();
+
                         cout << "exporting object space hierarchy ... ";
                         mHierarchyManager->ExportObjectSpaceHierarchy(exporter, objects);
                 
                         delete exporter;
-                        cout << "finished" << endl;
+                        cout << "finished in " << TimeDiff(starttime, GetTime()) * 1e-3f << " secs" << endl;
                 }
         }
@@ -5153 +5160 @@
         const bool sortViewCells = true;
 
-        // sort view cells to visualize the largest view cells
         if (sortViewCells)
         {
                 //stable_sort(mViewCells.begin(), mViewCells.end(), ViewCell::SmallerPvs);
+                // sort view cells to visualize the view cells with highest render cost
                 stable_sort(mViewCells.begin(), mViewCells.end(), ViewCell::LargerRenderCost);
         }
 
         int limit = min(leafOut, (int)mViewCells.size());
-
         int raysOut = 0;
 
-
+        ///////////////////////////
         //-- some rays for output
         
@@ -5249 +5255 @@
                                 }       
                                 
-                                //-- export rays piercing this view cell
+                                // export rays piercing this view cell
                                 exporter->ExportRays(vcRays, RgbColor(1, 1, 0));
                         }
                 }
 
+
+                /////////////////
                 //-- export view cell geometry
 
@@ -5267 +5275 @@
 
 #if 0   
+                //////////
                 //-- export pvs
 
@@ -5336 +5345 @@
                 return false;
 
+        const long starttime = GetTime();
         cout << "exporting view cells to xml ... ";
         
@@ -5349 +5359 @@
         //////////////////////////////////////////////////////////////
         //-- export bounding boxes
+        //-- The bounding boxes are used to identify 
+        //-- the objects in the rendering engine
 
         stream << "<BoundingBoxes>" << endl;
@@ -5356 +5368 @@
         {
                         const AxisAlignedBox3 box = (*oit)->GetBox();
-
-                        //-- the bounding boxes
                         stream << "<BoundingBox" << " id=\"" << (*oit)->GetId() << "\""
                                    << " min=\"" << box.Min().x << " " << box.Min().y << " " << box.Min().z << "\""
                                    << " max=\"" << box.Max().x << " " << box.Max().y << " " << box.Max().z << "\" />" << endl;
         }
-
         stream << "</BoundingBoxes>" << endl;
 
-        ////////////////////////////////////////////////////////////////
+
+        //////////////////////////
         //-- export the view cells and the pvs
 
@@ -5374 +5384 @@
         stream << "</ViewCells>" << endl;
 
-
+        //////////////////////
         //-- export the view space hierarchy
         
@@ -5384 +5394 @@
         stream << "</ViewSpaceHierarchy>" << endl;
 
-        
+        //////////////////////  
         //-- export the object space partition
         
@@ -5392 +5402 @@
         stream.close();
         
-        cout << "finished" << endl;
-
+        cout << "finished in " << TimeDiff(starttime, GetTime()) * 1e-3 << " secs" << endl;
         return true;
 }

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

@@ -94 +94 @@
         app << "#N_LEAVES ( Number of leaves )\n" << Leaves() << "\n";
 
-        app << "#AXIS_ALIGNED_SPLITS (number of axis aligned splits)\n" << splits[0] + splits[1] + splits[2] << endl;
-
         app << "#N_SPLITS ( Number of splits in axes x y z)\n";
 
         for (int i = 0; i < 3; ++ i)
                 app << splits[i] << " ";
+
         app << endl;
 
@@ -529 +528 @@
                 || (data.mPvs <= mTermMinPvs)
                 || (data.mProbability <= mTermMinProbability)
-                || (data.GetAvgRayContribution() > mTermMaxRayContribution)
+                //|| (data.GetAvgRayContribution() > mTermMaxRayContribution)
                 || (data.mDepth >= mTermMaxDepth)
                 );
 
-        if (1 && localTerminationCriteriaMet)
-        {
-                Debug << "********local termination *********" << endl;
+        if (0 && localTerminationCriteriaMet)
+        {
+                Debug << "local termination criteria met:" << endl;
                 Debug << "rays: " << (int)data.mRays->size() << "  " << mTermMinRays << endl;
                 Debug << "pvs: " << data.mPvs << " " << mTermMinPvs << endl;
@@ -552 +551 @@
                 // || mOutOfMemory
                 || (mVspStats.Leaves() >= mMaxViewCells)
-        //|| (mGlobalCostMisses >= mTermGlobalCostMissTolerance) 
+        || (mGlobalCostMisses >= mTermGlobalCostMissTolerance) 
                 );
 
         if (0 && terminationCriteriaMet)
         {
-                Debug << "********* terminationCriteriaMet *********" << endl;
+                Debug << "globlal termination criteria met:" << endl;
                 Debug << "cost misses: " << mGlobalCostMisses << " " << mTermGlobalCostMissTolerance << endl;
                 Debug << "leaves: " << mVspStats.Leaves() << " " <<  mMaxViewCells << endl;
@@ -768 +767 @@
         VspLeaf *leaf = dynamic_cast<VspLeaf *>(tData.mNode);
         
-        ///////////////////////////////////////////////////////////////////
-        //-- the front and back traversal data is filled with the new values
+        ////////////////////////////////////////////////////////
+        //-- the front and back traversal data are filled with the new values
 
         frontData.mDepth = tData.mDepth + 1;
@@ -807 +806 @@
         // two more leaves
         mVspStats.nodes += 2;
-
+        /// and a new split
+        ++ mVspStats.splits[splitPlane.mAxis];
 
     ///////////////////////////////////////////

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

@@ -220 +220 @@
 void X3dParseHandlers::EndShape()
 {
-         //-- if shape is merely a definition => don't create particular mesh instance
-         if (!mCurrentMesh || mIsMeshDefinition) 
-         { 
-                 return;
-         }
-
-         ////////////////////////////////////
-         //-- each triangle is one single mesh
-
-         if (!mLoadMeshes)
-         {
-                 cout << "m";   
-                 Mesh tempMesh(*mCurrentMesh);
-                 ApplyTransformations(mTransformations, &tempMesh);
-
-                 FaceContainer::const_iterator fit, fit_end = tempMesh.mFaces.end();
-                
-                 for (fit = tempMesh.mFaces.begin(); fit != fit_end; ++ fit)
-                 {
-                         cout << "f";
-                         // triangulate the faces
-                         Face *face = *fit;
-                         vector<Triangle3> triangles;
-                         Polygon3 poly(face, &tempMesh);
-                         poly.Triangulate(triangles);
-
-                         vector<Triangle3>::const_iterator tit, tit_end = triangles.end();
-
-                         for (tit = triangles.begin(); tit != tit_end; ++ tit)
-                         {
-                                 //cout << "triangle: " << *tit << endl;
-                                 TriangleIntersectable *ti = new TriangleIntersectable(*tit);
-                                 mCurrentNode->mGeometry.push_back(ti);
-                         }
+        //////////////
+        //-- shape is only a definition => 
+        //-- don't create particular mesh instance
+
+        if (!mCurrentMesh || mIsMeshDefinition) 
+        { 
+                return;
+        }
+
+        if (!mLoadMeshes)
+        {
+                ////////////////////////////////////
+                //-- load data as single triangles instead of whole meshes
+
+                //cout << "m";  
+                Mesh tempMesh(*mCurrentMesh);
+                ApplyTransformations(mTransformations, &tempMesh);
+
+                FaceContainer::const_iterator fit, fit_end = tempMesh.mFaces.end();
+
+                for (fit = tempMesh.mFaces.begin(); fit != fit_end; ++ fit)
+                {
+                        //cout << "f";
+                        // triangulate the faces
+                        Face *face = *fit;
+                        vector<Triangle3> triangles;
+                        Polygon3 poly(face, &tempMesh);
+                        poly.Triangulate(triangles);
+
+                        vector<Triangle3>::const_iterator tit, tit_end = triangles.end();
+
+                        for (tit = triangles.begin(); tit != tit_end; ++ tit)
+                        {
+                                //cout << "triangle: " << *tit << endl;
+                                TriangleIntersectable *ti = new TriangleIntersectable(*tit);
+                                mCurrentNode->mGeometry.push_back(ti);
+                        }
 #if 0
-                         // we create a new mesh for each face from the current mesh
-                         Mesh *mesh = MeshManager::GetSingleton()->CreateResource();
-                        
-                         VertexIndexContainer::const_iterator vit, vit_end = face->mVertexIndices.end();
-                
-                         int i = 0;
-                         // dummy vertex indices container
-                         VertexIndexContainer vcIndices;
-
-                         for (vit = face->mVertexIndices.begin(); vit != vit_end; ++ vit, ++ i)
-                         {
-                                 cout << "i";
-                                 const int index = (*vit);
-                                 // add vertices
-                                 mesh->mVertices.push_back(mCurrentMesh->mVertices[index]);
-                                 // indices don't make much sense if mesh == face, but we need them anyway ...
-                                 vcIndices.push_back(i);
-                         }
-
-                         mesh->mFaces.push_back(new Face(vcIndices));
-
-                         // write transformations directly into the mesh
-                         // note: could be transformed in parent mesh, save some transformations
-                         ApplyTransformations(mTransformations, mesh);
-
-                         mesh->Preprocess();
-                                
-                         if (mesh->mFaces.empty())
-                         {
-                                 cout << "error: empy mesh" << endl;
-                         }
-                         else
-                         {
-                                 // make an instance of this mesh
-                                 MeshInstance *mi = new MeshInstance(mesh);
-                                 mCurrentNode->mGeometry.push_back(mi);
-
-                                 if (mCurrentMaterial && !mCurrentMesh->mMaterial)
-                                 {
-                                         // HACK: add the material to the mesh directly if no material yet
-                                         mCurrentMesh->mMaterial = mCurrentMaterial;
-                                 }
-                         }
+                        // we create a new mesh for each face from the current mesh
+                        Mesh *mesh = MeshManager::GetSingleton()->CreateResource();
+
+                        VertexIndexContainer::const_iterator vit, vit_end = face->mVertexIndices.end();
+
+                        int i = 0;
+                        // dummy vertex indices container
+                        VertexIndexContainer vcIndices;
+
+                        for (vit = face->mVertexIndices.begin(); vit != vit_end; ++ vit, ++ i)
+                        {
+                                cout << "i";
+                                const int index = (*vit);
+                                // add vertices
+                                mesh->mVertices.push_back(mCurrentMesh->mVertices[index]);
+                                // indices don't make much sense if mesh == face, but we need them anyway ...
+                                vcIndices.push_back(i);
+                        }
+
+                        mesh->mFaces.push_back(new Face(vcIndices));
+
+                        // write transformations directly into the mesh
+                        // note: could be transformed in parent mesh, save some transformations
+                        ApplyTransformations(mTransformations, mesh);
+
+                        mesh->Preprocess();
+
+                        if (mesh->mFaces.empty())
+                        {
+                                cout << "error: empy mesh" << endl;
+                        }
+                        else
+                        {
+                                // make an instance of this mesh
+                                MeshInstance *mi = new MeshInstance(mesh);
+                                mCurrentNode->mGeometry.push_back(mi);
+
+                                if (mCurrentMaterial && !mCurrentMesh->mMaterial)
+                                {
+                                        // HACK: add the material to the mesh directly if no material yet
+                                        mCurrentMesh->mMaterial = mCurrentMaterial;
+                                }
+                        }
 #endif
-                 }
-
-                 // this mesh is not needed, unless it is used as a definition
-                 if (!mUsingMeshDefinition)
-                 {
-                         MeshManager::GetSingleton()->DestroyEntry(mCurrentMesh->GetId());
-                 }
+                }
+
+                // this mesh is not needed, unless it is used as a definition
+                if (!mUsingMeshDefinition)
+                {
+                        MeshManager::GetSingleton()->DestroyEntry(mCurrentMesh->GetId());
+                }
         }
         else // default usage: create a mesh instance from the current mesh
@@ -321 +324 @@
                 else
                 {
-                         // make an instance of this mesh
+                        // make an instance of this mesh
                         TransformedMeshInstance *tmi = new TransformedMeshInstance(mCurrentMesh);
 
-                         // apply transformation on the instance of the mesh 
-                         ApplyTransformations(mTransformations, tmi);
-                         mi = tmi;
-                }
-                        
+                        // apply transformation on the instance of the mesh 
+                        ApplyTransformations(mTransformations, tmi);
+                        mi = tmi;
+                }
+
                 if (mCurrentMaterial)
                 {
@@ -341 +344 @@
                         }
                 }
-                
+
                 // create local mesh kd tree
                 mCurrentMesh->Preprocess();
@@ -368 +371 @@
 
         VertexIndexContainer vertices;
-  
+
         mIsMeshDefinition = false;
         mUsingMeshDefinition = false;
@@ -579 +582 @@
  
   if (element == "Shape") {
-          cout << "+"; 
+          //cout << "+"; 
 
           // reset current shape values

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

@@ -149 +149 @@
         }
 
-        ////////////////////////////////////////
+
+        /////////////
         //-- load scene 
 
@@ -175 +176 @@
                 exit(1);
         }
-
-        bool loadKdTree, exportKdTree;
-
-        Environment::GetSingleton()->GetBoolValue("Preprocessor.loadKdTree", loadKdTree);
-
-        const string kdtreename("kd.bin.gz");
-
-        if (!loadKdTree)
-        {
-                //-- build new kd tree from scene geometry
-                preprocessor->BuildKdTree();
-                preprocessor->KdTreeStatistics(cout);
-        }
-        else
-        {
-                const long startTime = GetTime();
-                cout << "loading kd tree ... ";
-
-                if (!preprocessor->LoadKdTree(kdtreename))
-                {
-                        cout << "error loading kd tree with filename " << kdtreename << endl;
-                        Cleanup();
-                        exit(1);
-                }
-                cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-
-                if (0)
-                {
-                        Exporter *exporter = Exporter::GetExporter("dummykd.x3d");
-                        
-                        if (exporter)
-                        {
-                                exporter->ExportKdTree(*preprocessor->mKdTree, true);
-                                delete exporter;
-                        }
-                }
-        }
-
-        Environment::GetSingleton()->GetBoolValue("Preprocessor.exportKdTree", exportKdTree);
-
-        if (exportKdTree)
-        {
-                const long startTime = GetTime();
-                cout << "exporting kd tree ... ";
-                if (!preprocessor->ExportKdTree(kdtreename))
-                {
-                        cout << " error exporting kd tree with filename " << kdtreename << endl;
-                }
-                else
-                {
-                        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-                }
-        }
-
 
         // parse view cells related options
@@ -301 +248 @@
         }
         
+        // release memory
         Cleanup();