Changeset 503 for trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.cpp

Timestamp:

01/05/06 20:41:52 (19 years ago)

Author:

mattausch

Message:

added mesh creation function

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.cpp (modified) (127 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.cpp

@@ -37 +37 @@
 void ViewCellsManager::ParseEnvironment()
 {
-        // post processing stuff
-        environment->GetIntValue("ViewCells.PostProcess.minPvsDif", mMinPvsDif);
-        environment->GetIntValue("ViewCells.PostProcess.minPvs", mMinPvs);
-        environment->GetIntValue("ViewCells.PostProcess.maxPvs", mMaxPvs);
-
+        // visualization stuff
         environment->GetBoolValue("ViewCells.Visualization.exportRays", mExportRays);
         environment->GetBoolValue("ViewCells.Visualization.exportGeometry", mExportGeometry);
 
         char buf[50];
-        
+
         environment->GetStringValue("ViewCells.Visualization.colorCode", buf);
-        
+
         if (strcmp(buf, "PVS") == 0)
                 mColorCode = 1;
@@ -65 +61 @@
 {
         DEL_PTR(mRenderer);
-
         CLEAR_CONTAINER(mViewCells);
+        CLEAR_CONTAINER(mMeshContainer);
 }
 
@@ -73 +69 @@
 {
         X3dParser parser;
-        
+
         environment->GetFloatValue("ViewCells.height", parser.mViewCellHeight);
-        
+
         bool success = parser.ParseFile(filename, *this);
         Debug << (int)mViewCells.size() << " view cells loaded" << endl;
@@ -102 +98 @@
         if (!ViewCellsConstructed())
                 return;
-  
+
         VssRayContainer::const_iterator it, it_end = rays.end();
 
-        for (it = rays.begin(); it != it_end; ++ it) 
-        {       
+        for (it = rays.begin(); it != it_end; ++ it)
+        {
                 ComputeSampleContributions(*(*it));
         }
@@ -143 +139 @@
 
 
-void ViewCellsManager::DeriveViewCells(const ObjectContainer &objects, 
-                                                                           ViewCellContainer &viewCells, 
+void ViewCellsManager::DeriveViewCells(const ObjectContainer &objects,
+                                                                           ViewCellContainer &viewCells,
                                                                            const int maxViewCells) const
 {
         // maximal max viewcells
-        int limit = maxViewCells > 0 ? 
+        int limit = maxViewCells > 0 ?
                 Min((int)objects.size(), maxViewCells) : (int)objects.size();
 
@@ -154 +150 @@
         {
                 Intersectable *object = objects[i];
-                
+
                 // extract the mesh instances
                 if (object->Type() == Intersectable::MESH_INSTANCE)
@@ -168 +164 @@
 
 
-ViewCell *ViewCellsManager::ExtrudeViewCell(const Triangle3 &baseTri, 
+ViewCell *ViewCellsManager::ExtrudeViewCell(const Triangle3 &baseTri,
                                                                                         const float height) const
 {
         // one mesh per view cell
         Mesh *mesh = new Mesh();
-        
+
         //-- construct prism
 
-        // bottom 
+        // bottom
         mesh->mFaces.push_back(new Face(2,1,0));
         // top
@@ -188 +184 @@
         Vector3 triNorm = baseTri.GetNormal();
 
-        Triangle3 topTri;       
+        Triangle3 topTri;
 
         // add base vertices and calculate top vertices
         for (int i = 0; i < 3; ++ i)
                 mesh->mVertices.push_back(baseTri.mVertices[i]);
-        
-        // add top vertices     
+
+        // add top vertices
         for (int i = 0; i < 3; ++ i)
                 mesh->mVertices.push_back(baseTri.mVertices[i] + height * triNorm);
-        
+
         mesh->Preprocess();
 
@@ -217 +213 @@
 
         std::merge(front.mPiercingRays.begin(), front.mPiercingRays.end(),
-                           back.mPiercingRays.begin(), back.mPiercingRays.end(), 
+                           back.mPiercingRays.begin(), back.mPiercingRays.end(),
                            vc->mPiercingRays.begin());
 
@@ -321 +317 @@
 {
         mViewCells.clear();
-        
+
         CollectViewCells();
         mViewCellsStats.Reset();
@@ -336 +332 @@
 
   ViewCellContainer viewcells;
-                
+
   ray.mPvsContribution = 0;
   ray.mRelativePvsContribution = 0.0f;
@@ -343 +339 @@
   Ray hray(ray);
   float tmin = 0, tmax = 1.0;
-  
+
   //hray.Init(ray.GetOrigin(), ray.GetDir(), Ray::LINE_SEGMENT);
   if (!GetSceneBbox().GetRaySegment(hray, tmin, tmax) || (tmin > tmax))
         return;
-  
+
   Vector3 origin = hray.Extrap(tmin);
   Vector3 termination = hray.Extrap(tmax);
-  
+
   CastLineSegment(origin,
                                   termination,
                                   viewcells);
-  
+
   // copy viewcells memory efficiently
   const bool storeViewcells = false;
@@ -361 +357 @@
         ray.mViewCells = viewcells;
   }
-  
+
   ViewCellContainer::const_iterator it = viewcells.begin();
 
@@ -367 +363 @@
 
   if (addInPlace) {
-        for (; it != viewcells.end(); ++it) {   
+        for (; it != viewcells.end(); ++it) {
           ViewCell *viewcell = *it;
-          
+
           // if ray not outside of view space
           float contribution;
-          bool added = 
+          bool added =
                 viewcell->GetPvs().AddSample(ray.mTerminationObject,
                                                                          contribution
@@ -378 +374 @@
           if (added)
                 ray.mPvsContribution++;
-          
+
           ray.mRelativePvsContribution += contribution;
         }
   } else {
-    for (; it != viewcells.end(); ++it) {       
+    for (; it != viewcells.end(); ++it) {
           ViewCell *viewcell = *it;
           // if ray not outside of view space
@@ -390 +386 @@
                                                                                                    ))
                 ray.mPvsContribution++;
-          
+
           ray.mRelativePvsContribution += contribution;
         }
 
-        for (it = viewcells.begin(); it != viewcells.end(); ++it) {     
+        for (it = viewcells.begin(); it != viewcells.end(); ++it) {
           ViewCell *viewcell = *it;
           // if ray not outside of view space
@@ -405 +401 @@
 void ViewCellsManager::GetRaySets(const VssRayContainer &sourceRays,
                                                                   const int maxSize,
-                                                                  VssRayContainer &usedRays, 
+                                                                  VssRayContainer &usedRays,
                                                                   VssRayContainer *savedRays) const
 {
@@ -461 +457 @@
 
 
+
+void ViewCellsManager::CreateViewCellsMeshes()
+{
+        // convert to meshes
+        ViewCellContainer::const_iterator it, it_end = mViewCells.end();
+
+        for (it = mViewCells.begin(); it != it_end; ++ it)
+        {
+                CreateMesh(*it);
+        }
+}
+
 /**********************************************************************/
 /*                   BspViewCellsManager implementation               */
@@ -466 +474 @@
 
 
-BspViewCellsManager::BspViewCellsManager(BspTree *bspTree, 
+BspViewCellsManager::BspViewCellsManager(BspTree *bspTree,
                                                                                  int constructionSamples):
-ViewCellsManager(constructionSamples), 
+ViewCellsManager(constructionSamples),
 mBspTree(bspTree)
 {
@@ -486 +494 @@
 
 
-int BspViewCellsManager::Construct(const ObjectContainer &objects, 
+int BspViewCellsManager::Construct(const ObjectContainer &objects,
                                                                    const VssRayContainer &rays)
 {
@@ -494 +502 @@
 
         int sampleContributions = 0;
-        
+
         // construct view cells using the collected samples
         RayContainer constructionRays;
@@ -513 +521 @@
         }
 
-    if (mViewCells.empty()) 
-        { 
-                // no view cells loaded 
+    if (mViewCells.empty())
+        {
+                // no view cells loaded
                 mBspTree->Construct(objects, constructionRays);
                 // collect final view cells
                 mBspTree->CollectViewCells(mViewCells);
-        } 
+        }
         else
         {
@@ -529 +537 @@
 
         Debug << mBspTree->GetStatistics() << endl;
-        
-        EvaluateViewCellsStats();
+
+        //EvaluateViewCellsStats();
         Debug << "\nView cells after construction:\n" << mViewCellsStats << endl;
 
@@ -536 +544 @@
         ComputeSampleContributions(savedRays);
 
+
         return sampleContributions;
 }
 
+
 void BspViewCellsManager::CollectViewCells()
 {
         mBspTree->CollectViewCells(mViewCells);
 }
+
 
 float BspViewCellsManager::GetProbability(ViewCell *viewCell)
@@ -553 +564 @@
 #endif
 }
-  
+
 
 float BspViewCellsManager::GetRendercost(ViewCell *viewCell, float objRendercost) const
@@ -575 +586 @@
 
 
-int BspViewCellsManager::PostProcess(const ObjectContainer &objects, 
+int BspViewCellsManager::PostProcess(const ObjectContainer &objects,
                                                                          const VssRayContainer &rays)
 {
@@ -601 +612 @@
                 cout << "exporting initial view cells (=leaves) ... ";
                 Exporter *exporter = Exporter::GetExporter("view_cells.x3d");
-        
+
                 if (exporter)
                 {
@@ -607 +618 @@
                         exporter->SetFilled();
                         ExportViewCells(exporter);
-                                
+
                         if (mExportGeometry)
                         {
@@ -624 +635 @@
 
         cout << "starting post processing using " << mPostProcessSamples << " samples ... ";
-                
+
         long startTime = GetTime();
 
@@ -637 +648 @@
         CLEAR_CONTAINER(mBspRays);
         ConstructBspRays(rays, mPostProcessSamples);
-        
+
         for (int i = 0; i < (int)mBspRays.size(); ++ i)
-        {  
+        {
                 BspRay *ray = mBspRays[i];
-          
+
                 // traverse leaves stored in the rays and compare and merge consecutive
                 // leaves (i.e., the neighbors in the tree)
                 if (ray->intersections.size() < 2)
                         continue;
-          
+
                 iit = ray->intersections.begin();
 
                 BspLeaf *previousLeaf = (*iit).mLeaf;
                 ++ iit;
-                
+
                 for (; iit != ray->intersections.end(); ++ iit)
                 {
@@ -657 +668 @@
 
                         if (ShouldMerge(leaf, previousLeaf))
-                        {                       
+                        {
                                 MergeBspLeafViewCells(leaf, previousLeaf);
 
                                 ++ merged;
                         }
-                
+
                         previousLeaf = leaf;
                 }
@@ -673 +684 @@
 
         Debug << "Postprocessing: Merged " << merged << " view cells in "
-                  << TimeDiff(startTime, GetTime()) *1e-3 << " secs" 
+                  << TimeDiff(startTime, GetTime()) *1e-3 << " secs"
                   << "using " << (int)mBspRays.size() << " samples" << endl << endl;
-        
+
         CLEAR_CONTAINER(mBspRays);
 
@@ -704 +715 @@
         CLEAR_CONTAINER(mBspRays);
         ConstructBspRays(sampleRays, mVisualizationSamples);
-        
+
         if (1) // export view cells
         {
@@ -715 +726 @@
                         delete exporter;
                 }
-                
+
                 cout << "finished" << endl;
-        }       
+        }
 
         //-- visualization of the BSP splits
         bool exportSplits = false;
         environment->GetBoolValue("BspTree.Visualization.exportSplits", exportSplits);
-        
+
         if (exportSplits)
         {
@@ -734 +745 @@
 
 
-inline bool vc_gt(ViewCell *a, ViewCell *b) 
-{ 
+inline bool vc_gt(ViewCell *a, ViewCell *b)
+{
         return a->GetPvs().GetSize() > b->GetPvs().GetSize();
 }
@@ -744 +755 @@
         Exporter *exporter = Exporter::GetExporter("bsp_splits.x3d");
 
-        if (exporter) 
-        {       
-                Material m; 
+        if (exporter)
+        {
+                Material m;
                 m.mDiffuseColor = RgbColor(1, 0, 0);
                 exporter->SetForcedMaterial(m);
                 exporter->SetWireframe();
-                
+
                 exporter->ExportBspSplits(*mBspTree, true);
 
@@ -759 +770 @@
 
                 exporter->SetFilled();
-                                
+
                 // export rays
                 if (0)
                 {
                         VssRayContainer outRays;
-                
+
                         int raysSize = min((int)mBspRays.size(), mVisualizationSamples);
 
@@ -770 +781 @@
                                 // only rays piercing geometry
                                 outRays.push_back(mBspRays[i]->vssRay);
-                                                
-                        // export rays 
+
+                        // export rays
                         exporter->ExportRays(outRays, RgbColor(1, 1, 0));
                 }
@@ -786 +797 @@
 {
         const int leafOut = 10;
-        
+
         ViewCell::NewMail();
 
         //-- some rays for output
         const int raysOut = min((int)mBspRays.size(), mVisualizationSamples);
-        
+
         cout << "visualization using " << mVisualizationSamples << " samples" << endl;
         Debug << "\nOutput view cells: " << endl;
-        
+
         // sort view cells to get largest view cells
 #if 0
         stable_sort(mViewCells.begin(), mViewCells.end(), vc_gt);
 #endif
-        int limit = min(leafOut, (int)mViewCells.size()); 
-                
+        int limit = min(leafOut, (int)mViewCells.size());
+
         for (int i = 0; i < limit; ++ i)
         {
@@ -815 +826 @@
 #if 0
                 // check whether we can add the current ray to the output rays
-                for (int k = 0; k < raysOut; ++ k) 
+                for (int k = 0; k < raysOut; ++ k)
                 {
                         BspRay *ray = mBspRays[k];
@@ -821 +832 @@
                         {
                                 BspLeaf *leaf = ray->intersections[j].mLeaf;
-                                if (vc == leaf->GetViewCell()) 
+                                if (vc == leaf->GetViewCell())
                                         vcRays.push_back(ray->vssRay);
                         }
@@ -830 +841 @@
 
                 Exporter *exporter = Exporter::GetExporter(s);
-                        
+
                 exporter->SetWireframe();
 
@@ -841 +852 @@
                 else
                 {
-                        PolygonContainer vcGeom;
-                        
+                        BspNodeGeometry vcGeom;
+
                         //-- export view cell
                         mBspTree->ConstructGeometry(vc, vcGeom);
-                        exporter->ExportPolygons(vcGeom);
-                        CLEAR_CONTAINER(vcGeom);
-                }
-                        
-                Debug << i << ": pvs size=" << (int)vc->GetPvs().GetSize() 
+                        exporter->ExportPolygons(vcGeom.mPolys);
+                }
+
+                Debug << i << ": pvs size=" << (int)vc->GetPvs().GetSize()
                           << ", piercing rays=" << (int)vcRays.size()
                           << ", leaves=" << (int)vc->mLeaves.size() << endl;
 
-                        
+
                 // export rays piercing this view cell
 #if 0
@@ -871 +881 @@
 
                 // output PVS of view cell
-                for (it = vc->GetPvs().mEntries.begin(); it != it_end; ++ it) 
+                for (it = vc->GetPvs().mEntries.begin(); it != it_end; ++ it)
                 {
                         Intersectable *intersect = (*it).first;
@@ -882 +892 @@
                                 exporter->ExportIntersectable(intersect);
                                 intersect->Mail();
-                        }                       
-                }
-                                
+                        }
+                }
+
                 DEL_PTR(exporter);
                 cout << "finished" << endl;
@@ -895 +905 @@
 bool BspViewCellsManager::MergeBspLeafViewCells(BspLeaf *front, BspLeaf *back) const
 {
-        BspViewCell *viewCell = 
-                dynamic_cast<BspViewCell *>(MergeViewCells(*front->GetViewCell(), 
+        BspViewCell *viewCell =
+                dynamic_cast<BspViewCell *>(MergeViewCells(*front->GetViewCell(),
                                                                                                    *back->GetViewCell()));
-        
+
         if (!viewCell)
                 return false;
@@ -910 +920 @@
 
         vector<BspLeaf *>::const_iterator it;
-        
+
         for (it = fLeaves.begin(); it != fLeaves.end(); ++ it)
         {
@@ -921 +931 @@
                 viewCell->mLeaves.push_back(*it);
         }
-        
+
         DEL_PTR(fVc);
         DEL_PTR(bVc);
@@ -940 +950 @@
         if (fvc->GetPvs().GetSize() + fdiff < mMaxPvs)
         {
-                if ((fvc->GetPvs().GetSize() < mMinPvs) ||      
+                if ((fvc->GetPvs().GetSize() < mMinPvs) ||
                         (bvc->GetPvs().GetSize() < mMinPvs) ||
                         ((fdiff < mMinPvsDif) && (bvc->GetPvs().Diff(fvc->GetPvs()) < mMinPvsDif)))
@@ -947 +957 @@
                 }
         }
-        
+
         return false;
 }
@@ -979 +989 @@
 
 
-void BspViewCellsManager::ExportColor(Exporter *exporter, 
+void BspViewCellsManager::ExportColor(Exporter *exporter,
                                                                           ViewCell *vc) const
 {
@@ -994 +1004 @@
         case 1: // pvs
                 {
-                        importance = (float)vc->GetPvs().GetSize() / 
+                        importance = (float)vc->GetPvs().GetSize() /
                                 (float)mViewCellsStats.maxPvs;
                 }
@@ -1002 +1012 @@
                         BspViewCell *bspVc = dynamic_cast<BspViewCell *>(vc);
 
-                        importance = (float)bspVc->mLeaves.size() / 
+                        importance = (float)bspVc->mLeaves.size() /
                                 (float)mViewCellsStats.maxLeaves;
                 }
@@ -1019 +1029 @@
         m.mDiffuseColor.r = importance;
         m.mDiffuseColor.g = 1.0f - m.mDiffuseColor.r;
-        
+
         exporter->SetForcedMaterial(m);
 }
 
-void BspViewCellsManager::ExportVcGeometry(Exporter *exporter, 
+void BspViewCellsManager::ExportVcGeometry(Exporter *exporter,
                                                                                  ViewCell *vc) const
 {
@@ -1030 +1040 @@
         else
         {
-                PolygonContainer cell;
+                BspNodeGeometry geom;
                 mBspTree->ConstructGeometry(
-                        dynamic_cast<BspViewCell *>(vc), cell);
-                exporter->ExportPolygons(cell);
-        }
+                        dynamic_cast<BspViewCell *>(vc), geom);
+                exporter->ExportPolygons(geom.mPolys);
+        }
+}
+
+
+void BspViewCellsManager::CreateMesh(ViewCell *vc)
+{
 }
 
@@ -1048 +1063 @@
 /*                   KdViewCellsManager implementation               */
 /**********************************************************************/
+
+
 
 KdViewCellsManager::KdViewCellsManager(KdTree *kdTree):
@@ -1085 +1102 @@
 }
 
-int KdViewCellsManager::Construct(const ObjectContainer &objects, 
+int KdViewCellsManager::Construct(const ObjectContainer &objects,
                                                                   const VssRayContainer &rays)
 {
@@ -1097 +1114 @@
         // create the view cells
         mKdTree->CreateAndCollectViewCells(mViewCells);
-        
+
         // cast rays
         ComputeSampleContributions(rays);
@@ -1112 +1129 @@
 }
 
-int KdViewCellsManager::PostProcess(const ObjectContainer &objects, 
+int KdViewCellsManager::PostProcess(const ObjectContainer &objects,
                                                                         const VssRayContainer &rays)
 {
@@ -1135 +1152 @@
         {
                 const int leafOut = 10;
-                
+
                 ViewCell::NewMail();
-  
+
                 //-- some rays for output
                 const int raysOut = min((int)sampleRays.size(), mVisualizationSamples);
@@ -1144 +1161 @@
                 //-- some random view cells and rays for output
                 vector<KdLeaf *> kdLeaves;
-                
+
                 for (int i = 0; i < leafOut; ++ i)
                         kdLeaves.push_back(dynamic_cast<KdLeaf *>(mKdTree->GetRandomLeaf()));
-                
+
                 for (int i = 0; i < kdLeaves.size(); ++ i)
                 {
                         KdLeaf *leaf = kdLeaves[i];
                         RayContainer vcRays;
-                        
+
                         cout << "creating output for view cell " << i << " ... ";
-#if 0                   
+#if 0
                         // check whether we can add the current ray to the output rays
-                        for (int k = 0; k < raysOut; ++ k) 
+                        for (int k = 0; k < raysOut; ++ k)
                         {
                                 Ray *ray = sampleRays[k];
-                                
+
                                 for (int j = 0; j < (int)ray->bspIntersections.size(); ++ j)
                                 {
                                         BspLeaf *leaf2 = ray->bspIntersections[j].mLeaf;
-                                        
-                                        if (leaf->GetViewCell() == leaf2->GetViewCell()) 
+
+                                        if (leaf->GetViewCell() == leaf2->GetViewCell())
                                         {
                                                 vcRays.push_back(ray);
@@ -1170 +1187 @@
                                 }
                         }
-#endif                  
+#endif
                         Intersectable::NewMail();
-                        
+
                         ViewCell *vc = leaf->mViewCell;
-                        
+
                         //bspLeaves[j]->Mail();
                         char s[64]; sprintf(s, "kd-pvs%04d.x3d", i);
-                        
+
                         Exporter *exporter = Exporter::GetExporter(s);
                         exporter->SetFilled();
@@ -1183 +1200 @@
                         exporter->SetWireframe();
                         //exporter->SetFilled();
-                        
+
                         Material m;//= RandomMaterial();
                         m.mDiffuseColor = RgbColor(1, 1, 0);
                         exporter->SetForcedMaterial(m);
-                        
+
                         AxisAlignedBox3 box = mKdTree->GetBox(leaf);
                         exporter->ExportBox(box);
 
-                        Debug << i << ": pvs size=" << (int)vc->GetPvs().GetSize() 
+                        Debug << i << ": pvs size=" << (int)vc->GetPvs().GetSize()
                                 << ", piercing rays=" << (int)vcRays.size() << endl;
-                        
+
                         // export rays piercing this view cell
-                        exporter->ExportRays(vcRays, 1000, RgbColor(0, 1, 0));  
-                        
+                        exporter->ExportRays(vcRays, 1000, RgbColor(0, 1, 0));
+
                         m.mDiffuseColor = RgbColor(1, 0, 0);
                         exporter->SetForcedMaterial(m);
-                        
+
                         // exporter->SetWireframe();
                         exporter->SetFilled();
-                        
+
                         ObjectPvsMap::iterator it, it_end = vc->GetPvs().mEntries.end();
                         // output PVS of view cell
-                        for (it = vc->GetPvs().mEntries.begin(); it !=  it_end; ++ it) 
+                        for (it = vc->GetPvs().mEntries.begin(); it !=  it_end; ++ it)
                         {
                                 Intersectable *intersect = (*it).first;
@@ -1212 +1229 @@
                                         exporter->ExportIntersectable(intersect);
                                         intersect->Mail();
-                                }                       
+                                }
                         }
-                        
+
                         DEL_PTR(exporter);
                         cout << "finished" << endl;
@@ -1226 +1243 @@
                 {
                         VssRay *ray = sampleRays[i];
-                
+
                         // check whether we can add this to the rays
-                        for (int j = 0; j < pvsOut; j++) 
+                        for (int j = 0; j < pvsOut; j++)
                         {
                                 if (objects[j] == ray->mTerminationObject)
@@ -1237 +1254 @@
                 }
 
-                if (exportRays) 
+                if (exportRays)
                 {
                         Exporter *exporter = NULL;
@@ -1243 +1260 @@
                         exporter->SetWireframe();
                         exporter->ExportKdTree(*mKdTree);
-                
-                        for (i=0; i < pvsOut; i++) 
+
+                        for (i=0; i < pvsOut; i++)
                                 exporter->ExportRays(rays[i], RgbColor(1, 0, 0));
 
                         exporter->SetFilled();
-                
+
                         delete exporter;
                 }
 
-                for (int k=0; k < pvsOut; k++) 
+                for (int k=0; k < pvsOut; k++)
                 {
                         Intersectable *object = objects[k];
-                        char s[64];     
+                        char s[64];
                         sprintf(s, "sample-pvs%04d.x3d", k);
 
                         Exporter *exporter = Exporter::GetExporter(s);
                         exporter->SetWireframe();
-                
+
                         KdPvsMap::iterator i = object->mKdPvs.mEntries.begin();
                         Intersectable::NewMail();
-                        
+
                         // avoid adding the object to the list
                         object->Mail();
                         ObjectContainer visibleObjects;
-            
-                        for (; i != object->mKdPvs.mEntries.end(); i++) 
+
+                        for (; i != object->mKdPvs.mEntries.end(); i++)
                         {
                                 KdNode *node = (*i).first;
                                 exporter->ExportBox(mKdTree->GetBox(node));
-                
+
                                 mKdTree->CollectObjects(node, visibleObjects);
                         }
-                
+
                         exporter->ExportRays(rays[k],  RgbColor(0, 1, 0));
                         exporter->SetFilled();
-                        
+
                         for (int j = 0; j < visibleObjects.size(); j++)
                                 exporter->ExportIntersectable(visibleObjects[j]);
-                        
+
                         Material m;
                         m.mDiffuseColor = RgbColor(1, 0, 0);
                         exporter->SetForcedMaterial(m);
                         exporter->ExportIntersectable(object);
-                
+
                         delete exporter;
                 }
-        }               
+        }
 }
 
@@ -1300 +1317 @@
 
 
-void KdViewCellsManager::ExportVcGeometry(Exporter *exporter, 
+void KdViewCellsManager::ExportVcGeometry(Exporter *exporter,
                                                                                   ViewCell *vc) const
 {
@@ -1335 +1352 @@
 
 
+void KdViewCellsManager::CreateMesh(ViewCell *vc)
+{
+}
+
 /**********************************************************************/
 /*                   VspKdViewCellsManager implementation             */
@@ -1340 +1361 @@
 
 
-VspKdViewCellsManager::VspKdViewCellsManager(VspKdTree *vspKdTree, 
+VspKdViewCellsManager::VspKdViewCellsManager(VspKdTree *vspKdTree,
                                                                                          int constructionSamples):
-ViewCellsManager(constructionSamples), 
+ViewCellsManager(constructionSamples),
 mVspKdTree(vspKdTree)
 {
@@ -1364 +1385 @@
 }
 
+
 void VspKdViewCellsManager::CollectViewCells()
 {
@@ -1369 +1391 @@
 }
 
-int VspKdViewCellsManager::Construct(const ObjectContainer &objects, 
+int VspKdViewCellsManager::Construct(const ObjectContainer &objects,
                                                                          const VssRayContainer &rays)
 {
@@ -1375 +1397 @@
         if (ViewCellsConstructed())
                 return 0;
-                
+
         VssRayContainer constructionRays;
         VssRayContainer savedRays;
 
-        GetRaySets(rays, 
-                           mConstructionSamples, 
-                           constructionRays, 
+        GetRaySets(rays,
+                           mConstructionSamples,
+                           constructionRays,
                            &savedRays);
-        
-        Debug << "constructing vsp kd tree using " 
+
+        Debug << "constructing vsp kd tree using "
                   << (int)constructionRays.size() << " samples" << endl;
 
@@ -1397 +1419 @@
 
         // collapse siblings belonging to the same view cell
+        mVspKdTree->RefineViewCells(rays);
+
+                // collapse siblings belonging to the same view cell
         mVspKdTree->CollapseTree();
-
-        // collapse siblings belonging to the same view cell
-        mVspKdTree->RefineViewCells(rays);
 
         // evaluale view cell stats
@@ -1410 +1432 @@
         // recast rest of rays
         ComputeSampleContributions(savedRays);
-        
-        Debug << "Computed remaining ray contribution in " << TimeDiff(startTime, GetTime()) * 1e-3 
+
+        Debug << "Computed remaining ray contribution in " << TimeDiff(startTime, GetTime()) * 1e-3
                   << " secs" << endl;
 
@@ -1428 +1450 @@
 }
 
-int VspKdViewCellsManager::PostProcess(const ObjectContainer &objects, 
+int VspKdViewCellsManager::PostProcess(const ObjectContainer &objects,
                                                                            const VssRayContainer &rays)
 {
@@ -1454 +1476 @@
 
         //-- export leaf building blocks
-        Exporter *exporter = Exporter::GetExporter("vspkdtree.x3d"); 
+        Exporter *exporter = Exporter::GetExporter("vspkdtree.x3d");
         if (!exporter)
                 return;
@@ -1462 +1484 @@
         exporter->ExportVspKdTree(*mVspKdTree);
 
-        if (mExportGeometry) 
+        if (mExportGeometry)
                 exporter->ExportGeometry(objects);
 
-        if (mExportRays) 
-        {
-                const float prob = (float)mVisualizationSamples 
+        if (mExportRays)
+        {
+                const float prob = (float)mVisualizationSamples
                         / ((float)sampleRays.size() + Limits::Small);
 
@@ -1491 +1513 @@
         if (!ViewCellsConstructed())
                 return;
-        
+
         //-- export single view cells
         for (int i = 0; i < 10; ++ i)
@@ -1498 +1520 @@
                 sprintf(s, "vsp_viewcell%04d.x3d", i);
                 Exporter *exporter = Exporter::GetExporter(s);
-                const int idx = 
+                const int idx =
                         (int)RandomValue(0.0, (Real)((int)mViewCells.size() - 1));
 
-                VspKdViewCell *vc = dynamic_cast<VspKdViewCell *>(mViewCells[idx]); 
+                VspKdViewCell *vc = dynamic_cast<VspKdViewCell *>(mViewCells[idx]);
 
                 cout << "Output view cell " << i << " with pvs size " << vc->GetPvs().GetSize() << endl;
@@ -1508 +1530 @@
                 Material m;
                 m.mDiffuseColor = RgbColor(0, 1, 1);
-                                
+
                 exporter->SetForcedMaterial(m);
                 exporter->SetWireframe();
@@ -1517 +1539 @@
                 if (mExportRays)
                 {
-                        vector<VspKdLeaf *>::const_iterator it, 
+                        vector<VspKdLeaf *>::const_iterator it,
                                 it_end = vc->mLeaves.end();
 
@@ -1540 +1562 @@
                                                 if ((*it)->mTerminationObject == NULL)
                                                         castRays.push_back(*it);
-                                                else 
+                                                else
                                                         initRays.push_back(*it);
                                 }
@@ -1560 +1582 @@
                 exporter->SetFilled();
 
-                for (it = vc->GetPvs().mEntries.begin(); it != it_end; ++ it) 
+                for (it = vc->GetPvs().mEntries.begin(); it != it_end; ++ it)
                 {
                         Intersectable *intersect = (*it).first;
@@ -1571 +1593 @@
                                 exporter->ExportIntersectable(intersect);
                                 intersect->Mail();
-                        }                       
+                        }
                 }
 
@@ -1578 +1600 @@
 
         //-- export final view cells
-        Exporter *exporter = Exporter::GetExporter("vspkdtree_merged.x3d"); 
-        
+        Exporter *exporter = Exporter::GetExporter("vspkdtree_merged.x3d");
+
         //if (exportGeometry) exporter->SetWireframe();
         //else exporter->SetFilled();
@@ -1585 +1607 @@
         ExportViewCells(exporter);
 
-        if (mExportGeometry) 
+        if (mExportGeometry)
         {
                 exporter->SetFilled();
@@ -1591 +1613 @@
         }
 
-        if (mExportRays) 
-        {
-                const float prob = (float)mVisualizationSamples 
+        if (mExportRays)
+        {
+                const float prob = (float)mVisualizationSamples
                         / ((float)sampleRays.size() + Limits::Small);
-                
+
                 exporter->SetWireframe();
-                        
+
                 VssRayContainer rays;
-                
+
                 for (int i = 0; i < sampleRays.size(); ++ i)
                 {
@@ -1605 +1627 @@
                         rays.push_back(sampleRays[i]);
                 }
-                exporter->ExportRays(rays, RgbColor(1, 0, 0));  
+                exporter->ExportRays(rays, RgbColor(1, 0, 0));
         }
 
@@ -1630 +1652 @@
         if (mColorCode == 0) // Random color
                 return;
-        
+
         float importance = 0;
 
@@ -1637 +1659 @@
         case 1: // pvs
                 {
-                        importance = (float)vc->GetPvs().GetSize() / 
+                        importance = (float)vc->GetPvs().GetSize() /
                                 (float)mViewCellsStats.maxPvs;
                 }
@@ -1645 +1667 @@
             VspKdViewCell *vspKdVc = dynamic_cast<VspKdViewCell *>(vc);
 
-                        importance = (float)vspKdVc->mLeaves.size() / 
+                        importance = (float)vspKdVc->mLeaves.size() /
                                 (float)mViewCellsStats.maxLeaves;
                 }
@@ -1651 +1673 @@
         case 3: // merged tree depth difference
                 {
-                        //importance = (float)GetMaxTreeDiff(vc) / 
+                        //importance = (float)GetMaxTreeDiff(vc) /
                         //      (float)(mVspBspTree->GetStatistics().maxDepth * 2);
                 }
@@ -1668 +1690 @@
 
 
-void VspKdViewCellsManager::ExportVcGeometry(Exporter *exporter, 
+void VspKdViewCellsManager::ExportVcGeometry(Exporter *exporter,
                                                                                    ViewCell *vc) const
 {
@@ -1684 +1706 @@
 
 
-/************************************************************************/
-/*                 VspBspViewCellsManager implementation                */
-/************************************************************************/
-
-
-VspBspViewCellsManager::VspBspViewCellsManager(VspBspTree *vspBspTree, 
+void VspKdViewCellsManager::CreateMesh(ViewCell *vc)
+{
+}
+
+/**************************************************************************/
+/*                   VspBspViewCellsManager implementation                */
+/**************************************************************************/
+
+
+VspBspViewCellsManager::VspBspViewCellsManager(VspBspTree *vspBspTree,
                                                                                            int constructionSamples):
-ViewCellsManager(constructionSamples), 
+ViewCellsManager(constructionSamples),
 mVspBspTree(vspBspTree)
 {
@@ -1719 +1745 @@
 
 
-float VspBspViewCellsManager::GetRendercost(ViewCell *viewCell, 
+float VspBspViewCellsManager::GetRendercost(ViewCell *viewCell,
                                                                                         float objRendercost) const
 {
@@ -1743 +1769 @@
 }
 
-int VspBspViewCellsManager::Construct(const ObjectContainer &objects, 
+int VspBspViewCellsManager::Construct(const ObjectContainer &objects,
                                                                           const VssRayContainer &rays)
 {
-  // if view cells were already constructed
-  if (ViewCellsConstructed())
-        return 0;
-  
-  Debug << "Constructing bsp view cells" << endl;
-  
-  int sampleContributions = 0;
-  
-  VssRayContainer sampleRays;
-  
-  int limit = min (mConstructionSamples, (int)rays.size());
-
-        
+        // if view cells were already constructed
+        if (ViewCellsConstructed())
+                return 0;
+
+        Debug << "Constructing bsp view cells" << endl;
+
+        int sampleContributions = 0;
+
+        VssRayContainer sampleRays;
+
+        int limit = min (mConstructionSamples, (int)rays.size());
+
         VssRayContainer constructionRays;
         VssRayContainer savedRays;
@@ -1768 +1793 @@
 
         mVspBspTree->Construct(constructionRays, &mSceneBox);
-        
+
         Debug << mVspBspTree->GetStatistics() << endl;
 
@@ -1774 +1799 @@
         cout << "collapsing invalid tree regions ... ";
         long startTime = GetTime();
-        int collapsedLeaves = mVspBspTree->CollapseTree(); 
+        int collapsedLeaves = mVspBspTree->CollapseTree();
         Debug << "collapsed in " << TimeDiff(startTime, GetTime()) * 1e-3 << " seconds" << endl;
     cout << "finished" << endl;
-        
+
         cout << "reseting view cell stats ... ";
         ResetViewCells();
         cout << "finished" << endl;
-        
+
         Debug << "\nView cells after construction:\n" << mViewCellsStats << endl;
 
@@ -1788 +1813 @@
                 cout << "exporting initial view cells (=leaves) ... ";
                 Exporter *exporter = Exporter::GetExporter("view_cells.x3d");
-        
+
                 if (exporter)
                 {
@@ -1797 +1822 @@
                         if (0 && mExportRays)
                                 exporter->ExportRays(rays, RgbColor(1, 1, 1));
-                        
+
                         if (mExportGeometry)
                                 exporter->ExportGeometry(objects);
-                        
+
                         delete exporter;
                 }
@@ -1807 +1832 @@
 
         startTime = GetTime();
+
+        //-- merge the individual view cells: Should be done here because it makes
+        MergeViewCells(rays, objects);
+        //-- refines the merged view cells
+        RefineViewCells(rays);
+        // collapse sibling leaves that share the same view cell
+        mVspBspTree->CollapseTree();
+
+        // reset view cells and stats
+        ResetViewCells();
+
         cout << "Computing remaining ray contributions ... ";
         // recast rest of rays
@@ -1812 +1848 @@
         cout << "finished" << endl;
 
-        Debug << "Computed remaining ray contribution in " << TimeDiff(startTime, GetTime()) * 1e-3 
+        Debug << "Computed remaining ray contribution in " << TimeDiff(startTime, GetTime()) * 1e-3
                   << " secs" << endl;
 
         cout << "construction finished" << endl;
+
         return sampleContributions;
 }
 
 
-// matt TODO: remove
-int VspBspViewCellsManager::MergeViewCells(const VssRayContainer &rays) const
-{
-        vector<BspIntersection>::const_iterator iit;
-        vector<BspRay *>bspRays;
-        int merged = 0;
-
-        mVspBspTree->ConstructBspRays(bspRays, rays);
-
-        for (int i = 0; i < (int)bspRays.size(); ++ i)
-        {
-                BspRay *ray = bspRays[i];
-          
-                // traverse leaves stored in the rays and compare and merge consecutive
-                // leaves (i.e., the neighbors in the tree)
-                if (ray->intersections.size() < 2)
-                        continue;
-          
-                iit = ray->intersections.begin();
-
-                BspLeaf *previousLeaf = (*iit).mLeaf;
-                ++ iit;
-                
-                for (; iit != ray->intersections.end(); ++ iit)
-                {
-                        BspLeaf *leaf = (*iit).mLeaf;
-
-                        if (ShouldMerge(leaf, previousLeaf))
-                        {                       
-                                mVspBspTree->MergeViewCells(leaf, previousLeaf);
-                                ++ merged;
-                        }
-                        previousLeaf = leaf;
-                }
-        }
-        CLEAR_CONTAINER(bspRays);
-
-        return merged;
-}
-        
-
-int VspBspViewCellsManager::PostProcess(const ObjectContainer &objects, 
-                                                                                const VssRayContainer &rays)
-{
-        if (!ViewCellsConstructed())
-        {
-                Debug << "view cells not constructed" << endl;
-                return 0;
-        }
-
+void VspBspViewCellsManager::MergeViewCells(const VssRayContainer &rays,
+                                                                                        const ObjectContainer &objects)
+{
         //-- post processing of bsp view cells
     int vcSize = 0;
@@ -1888 +1878 @@
         //-- merge or subdivide view cells
         int merged = 0;
-        
+
         cout << "starting merge using " << mPostProcessSamples << " samples ... ";
         long startTime = GetTime();
 
+        // TODO: should be done BEFORE the ray casting
         merged = mVspBspTree->MergeViewCells(postProcessRays);
 
@@ -1901 +1892 @@
         Debug << "Postprocessing: Merged " << merged << " view cells in "
                   << TimeDiff(startTime, GetTime()) *1e-3 << " secs" << endl << endl;
-        
+
         cout << "reseting view cell stats ... ";
         ResetViewCells();
@@ -1934 +1925 @@
                 cout << "finished" << endl;
         }
-
+}
+
+
+void VspBspViewCellsManager::RefineViewCells(const VssRayContainer &rays)
+{
         Debug << "render time before refine:" << endl;
         mRenderer->RenderScene();
+        SimulationStatistics ss;
         dynamic_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
     Debug << ss << endl;
 
         cout << "Refining the merged view cells ... ";
-        startTime = GetTime();
+        long startTime = GetTime();
 
         // refining the merged view cells
@@ -1953 +1949 @@
         Debug << "Postprocessing: refined " << refined << " view cells in "
                   << TimeDiff(startTime, GetTime()) *1e-3 << " secs" << endl << endl;
-        
-        // collapse sibling leaves that share the same view cell
-        mVspBspTree->CollapseTree();
-
-        // reset view cells and stats
-        ResetViewCells();
-
-        return merged;
+}
+
+int VspBspViewCellsManager::PostProcess(const ObjectContainer &objects,
+                                                                                const VssRayContainer &rays)
+{
+        if (!ViewCellsConstructed())
+        {
+                Debug << "view cells not constructed" << endl;
+                return 0;
+        }
+
+        CreateViewCellsMeshes();
+
+        return 0;
 }
 
@@ -1993 +1995 @@
 bool VspBspViewCellsManager::ViewPointValid(const Vector3 &viewPoint) const
 {
-        return mSceneBox.IsInside(viewPoint) && 
+        return mSceneBox.IsInside(viewPoint) &&
                    mVspBspTree->ViewPointValid(viewPoint);
 }
@@ -2026 +2028 @@
                         delete exporter;
                 }
-                
+
                 cout << "finished" << endl;
-        }       
+        }
 
         //-- visualization of the BSP splits
         bool exportSplits = false;
         environment->GetBoolValue("VspBspTree.Visualization.exportSplits", exportSplits);
-        
+
         if (exportSplits)
         {
@@ -2044 +2046 @@
         ExportBspPvs(objects, visRays);
 }
-        
+
 
 void VspBspViewCellsManager::ExportSplits(const ObjectContainer &objects,
@@ -2051 +2053 @@
         Exporter *exporter = Exporter::GetExporter("bsp_splits.x3d");
 
-        if (exporter) 
-        {       
-                Material m; 
+        if (exporter)
+        {
+                Material m;
                 m.mDiffuseColor = RgbColor(1, 0, 0);
                 exporter->SetForcedMaterial(m);
                 exporter->SetWireframe();
-                
+
                 exporter->ExportBspSplits(*mVspBspTree, true);
 
@@ -2066 +2068 @@
 
                 exporter->ResetForcedMaterial();
-                
+
                 // export rays
                 if (mExportRays)
                         exporter->ExportRays(rays, RgbColor(1, 1, 0));
-        
+
                 if (mExportGeometry)
                         exporter->ExportGeometry(objects);
@@ -2078 +2080 @@
 }
 
+
 void VspBspViewCellsManager::ExportBspPvs(const ObjectContainer &objects,
                                                                                   const VssRayContainer &rays)
 {
         const int leafOut = 10;
-        
+
         ViewCell::NewMail();
-        
+
         cout << "visualization using " << mVisualizationSamples << " samples" << endl;
         Debug << "\nOutput view cells: " << endl;
-        
+
         // sort view cells to visualize the largest view cells
 #if 0
         stable_sort(mViewCells.begin(), mViewCells.end(), vc_gt);
 #endif
-        int limit = min(leafOut, (int)mViewCells.size()); 
+        int limit = min(leafOut, (int)mViewCells.size());
 
 #if 1
@@ -2105 +2108 @@
         {
                 cout << "creating output for view cell " << i << " ... ";
-                
+
                 VssRayContainer vcRays;
                 Intersectable::NewMail();
@@ -2117 +2120 @@
 #if 1
                 // check whether we can add the current ray to the output rays
-                for (int k = 0; k < raysOut; ++ k) 
+                for (int k = 0; k < raysOut; ++ k)
                 {
                         BspRay *ray = bspRays[k];
@@ -2123 +2126 @@
                         {
                                 BspLeaf *leaf = ray->intersections[j].mLeaf;
-                                if (vc == leaf->GetViewCell()) 
+                                if (vc == leaf->GetViewCell())
                                         vcRays.push_back(ray->vssRay);
                         }
@@ -2137 +2140 @@
                 exporter->SetForcedMaterial(m);
 
-                ExportVcGeometry(exporter, vc); 
-                        
-                                
-                Debug << i << ": pvs size=" << (int)vc->GetPvs().GetSize() 
+                ExportVcGeometry(exporter, vc);
+
+
+                Debug << i << ": pvs size=" << (int)vc->GetPvs().GetSize()
                           << ", piercing rays=" << (int)vcRays.size()
                           << ", leaves=" << (int)vc->mLeaves.size() << endl;
-                
+
                 //-- export rays piercing this view cell
 #if 1
@@ -2163 +2166 @@
 
                 // output PVS of view cell
-                for (it = vc->GetPvs().mEntries.begin(); it != it_end; ++ it) 
+                for (it = vc->GetPvs().mEntries.begin(); it != it_end; ++ it)
                 {
                         Intersectable *intersect = (*it).first;
@@ -2174 +2177 @@
                                 exporter->ExportIntersectable(intersect);
                                 intersect->Mail();
-                        }                       
-                }
-                                
+                        }
+                }
+
                 DEL_PTR(exporter);
                 cout << "finished" << endl;
@@ -2188 +2191 @@
 
 
-bool VspBspViewCellsManager::ShouldMerge(BspLeaf *front, BspLeaf *back) const
-{
-        ViewCell *fvc = front->GetViewCell();
-        ViewCell *bvc = back->GetViewCell();
-
-        if (fvc == bvc)
-                return false;
-
-        const int fdiff = fvc->GetPvs().Diff(bvc->GetPvs());
-
-        if (fvc->GetPvs().GetSize() + fdiff < mMaxPvs)
-        {
-                if ((fvc->GetPvs().GetSize() < mMinPvs) ||      
-                        (bvc->GetPvs().GetSize() < mMinPvs) ||
-                        ((fdiff < mMinPvsDif) && 
-                         (bvc->GetPvs().Diff(fvc->GetPvs()) < mMinPvsDif)))
-                {
-                        return true;
-                }
-        }
-        
-        return false;
-}
-
-
 int VspBspViewCellsManager::CastLineSegment(const Vector3 &origin,
                                                                                         const Vector3 &termination,
@@ -2221 +2199 @@
 
 
-void VspBspViewCellsManager::ExportColor(Exporter *exporter, 
+void VspBspViewCellsManager::ExportColor(Exporter *exporter,
                                                                                  ViewCell *vc) const
 {
         if (mColorCode == 0) // Random color
                 return;
-        
+
         float importance = 0;
 
@@ -2233 +2211 @@
         case 1: // pvs
                 {
-                        importance = (float)vc->GetPvs().GetSize() / 
+                        importance = (float)vc->GetPvs().GetSize() /
                                 (float)mViewCellsStats.maxPvs;
                 }
@@ -2241 +2219 @@
             BspViewCell *bspVc = dynamic_cast<BspViewCell *>(vc);
 
-                        importance = (float)bspVc->mLeaves.size() / 
+                        importance = (float)bspVc->mLeaves.size() /
                                 (float)mViewCellsStats.maxLeaves;
                 }
@@ -2247 +2225 @@
         case 3: // merge tree differene
                 {
-                        importance = (float)GetMaxTreeDiff(vc) / 
+                        importance = (float)GetMaxTreeDiff(vc) /
                                 (float)(mVspBspTree->GetStatistics().maxDepth * 2);
                 }
@@ -2264 +2242 @@
 
 
-void VspBspViewCellsManager::ExportVcGeometry(Exporter *exporter, 
+void VspBspViewCellsManager::ExportVcGeometry(Exporter *exporter,
                                                                                           ViewCell *vc) const
 {
 #if 1
+    if (vc->GetMesh())
+        {
+                exporter->ExportMesh(vc->GetMesh());
+                return;
+        }
+
         BspNodeGeometry geom;
         mVspBspTree->
-                ConstructGeometry(dynamic_cast<BspViewCell *>(vc), geom.mPolys);
+                ConstructGeometry(dynamic_cast<BspViewCell *>(vc), geom);
         exporter->ExportPolygons(geom.mPolys);
 #else
-        
+
         Material m2;
         m2.mDiffuseColor.b = 0.3f + Random(0.7f);
@@ -2324 +2308 @@
 
 
-
-
-ViewCell *
-VspBspViewCellsManager::GetViewCell(const Vector3 &point)
+ViewCell *VspBspViewCellsManager::GetViewCell(const Vector3 &point)
 {
   if (!mVspBspTree)
@@ -2333 +2314 @@
   return mVspBspTree->GetViewCell(point);
 }
+
+
+void VspBspViewCellsManager::CreateMesh(ViewCell *vc)
+{
+        BspNodeGeometry geom;
+        BspViewCell *bspVc = dynamic_cast<BspViewCell *>(vc);
+        mVspBspTree->ConstructGeometry(bspVc, geom);
+
+        Mesh *mesh = new Mesh();
+        geom.AddToMesh(*mesh);
+        vc->SetMesh(mesh);
+        mMeshContainer.push_back(mesh);
+}