Changeset 503

Timestamp:

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

Author:

mattausch

Message:

added mesh creation function

Location:

trunk/VUT/GtpVisibilityPreprocessor

Files:

• scripts/default.env (modified) (8 diffs)
• src/AxisAlignedBox3.cpp (modified) (5 diffs)
• src/Containers.h (modified) (2 diffs)
• src/Environment.cpp (modified) (1 diff)
• src/Polygon3.cpp (modified) (2 diffs)
• src/Polygon3.h (modified) (1 diff)
• src/RssPreprocessor.cpp (modified) (1 diff)
• src/ViewCell.cpp (modified) (3 diffs)
• src/ViewCell.h (modified) (2 diffs)
• src/ViewCellBsp.cpp (modified) (16 diffs)
• src/ViewCellBsp.h (modified) (7 diffs)
• src/ViewCellsManager.cpp (modified) (127 diffs)
• src/ViewCellsManager.h (modified) (10 diffs)
• src/VspBspTree.cpp (modified) (21 diffs)
• src/VspBspTree.h (modified) (7 diffs)
• src/VspKdTree.cpp (modified) (1 diff)
• src/X3dExporter.cpp (modified) (1 diff)

trunk/VUT/GtpVisibilityPreprocessor/scripts/default.env

@@ -13 +13 @@
 #;../data/vienna/vienna-plane.x3d
 #       filename ../data/vienna/viewcells-25-sel.x3d
-#       filename ../data/atlanta/atlanta2.x3d
+        filename ../data/atlanta/atlanta2.x3d
 #       filename ../data/soda/soda.dat
-        filename ../data/soda/soda5.dat
+#       filename ../data/soda/soda5.dat
 }
 
@@ -30 +30 @@
         samplesPerPass  100000
         initialSamples 500000
-        vssSamples 200000
+        vssSamples 2000000
         vssSamplesPerPass 100000
         useImportanceSampling true
         loadInitialSamples  false
         storeInitialSamples false
-        useViewSpaceBox true
 }
 
@@ -181 +180 @@
         
         PostProcess {
-                minPvsDif 100
-                minPvs 10
-                maxPvs 150
                 # how much samples are used for post processing
                 samples 100000
@@ -196 +192 @@
                 colorCode Random
                 exportRays false
-                exportGeometry true
+                exportGeometry false
         }
         
@@ -223 +219 @@
         Termination {
                 maxDepth                40
-                minPvs                  1
-                minRays                 100
-                minSize                 0.0001
-                maxCostRatio            0.95
+                minPvs                  50
+                minRays                 300
+                minSize                 0.001
+                maxCostRatio            0.9
                 missTolerance           4
                 maxRayContribution      0.5
@@ -232 +228 @@
         
         maxTotalMemory  100
-        maxStaticMemory 80
+        maxStaticMemory 50
 
         splitType       regular
@@ -283 +279 @@
         Termination {
                 # parameters used for autopartition
-                minRays                 100
+                minRays                 200
                 minPolygons             -1
                 maxDepth                30
-                minPvs                  2
+                minPvs                  20
                 #minArea                0.0001
                 minArea                 0.000
-                maxRayContribution      0.005
+                maxRayContribution      0.05
                 maxCostRatio            0.9
-                missTolerance           4
+                missTolerance           5
                 #maxAccRayLength        100
                 
-                maxViewCells            8000
+                maxViewCells            20000
                 
                 # used for pvs criterium
@@ -309 +305 @@
         PostProcess {
                 maxCostRatio 0.1
-                minViewCells 200
+                minViewCells 500
                 maxPvsSize   1000
-                useRaysForMerge false
+                useRaysForMerge true
         }
 }

trunk/VUT/GtpVisibilityPreprocessor/src/AxisAlignedBox3.cpp

@@ -1786 +1786 @@
   
   Vector3 invDirection;
-  const float eps = 1e-6;
-  const float invEps = 1e6;
+  const float eps = 1e-6f;
+  const float invEps = 1e6f;
   
   // it does change the ray direction very slightly,
@@ -1793 +1793 @@
   
   if (fabs(direction.x) < eps) {
-    if (direction.x < 0.0)
+    if (direction.x < 0.0f)
       invDirection.x = -invEps;
     else
@@ -1799 +1799 @@
   }
   else
-    invDirection.x = 1.0 / direction.x;
+    invDirection.x = 1.0f / direction.x;
   
   if (fabs(direction.y) < eps) {
@@ -1808 +1808 @@
   }
   else
-    invDirection.y = 1.0 / direction.y;
+    invDirection.y = 1.0f / direction.y;
   
   if (fabs(direction.z) < eps) {
-    if (direction.z < 0.0)
+    if (direction.z < 0.0f)
       invDirection.z = -invEps;
     else
@@ -1817 +1817 @@
   }
   else
-    invDirection.z = 1.0 / direction.z;
-
-
-  
-  if (fabs(direction.x) < 0.001) {
+    invDirection.z = 1.0f / direction.z;
+
+
+  
+  if (fabs(direction.x) < 0.001f) {
     if (mMin.x < origin.x && mMax.x > origin.x) {
       minx = -MAXFLOAT;

trunk/VUT/GtpVisibilityPreprocessor/src/Containers.h

@@ -13 +13 @@
 class Polygon3;
 class Ray;
+class Mesh;
 
 /** Container storing polygons used during BSP tree construction.
@@ -40 +41 @@
 typedef vector<HierarchyNode *> NodeContainer;
 
-
 typedef vector<SceneGraphNode *> SceneGraphNodeContainer;
 
+typedef vector<Mesh *> MeshContainer;
 
 

trunk/VUT/GtpVisibilityPreprocessor/src/Environment.cpp

@@ -1229 +1229 @@
                                  "view_cells_max_pvs=",
                                  "300");
-
-  RegisterOption("ViewCells.PostProcess.minPvsDif",
-                                 optInt,
-                                 "view_cells_post_process_min_pvs_dif=",
-                                 "10");
-
-  RegisterOption("ViewCells.PostProcess.maxPvs",
-                                 optInt,
-                                 "view_cells_post_process_max_pvs=",
-                                 "300");
-
-  RegisterOption("ViewCells.PostProcess.minPvs",
-                                 optString,
-                                 "view_cells_post_process_min_pvs",
-                                 "10");
-  
+ 
   RegisterOption("ViewCells.filename",
                  optString,

trunk/VUT/GtpVisibilityPreprocessor/src/Polygon3.cpp

@@ -1 +1 @@
 #include "Polygon3.h"
-#include "Mesh.h"
 #include "Mesh.h"
 #include "AxisAlignedBox3.h"
 #include "Ray.h"
+#include "Triangle3.h"
 
 Polygon3::Polygon3(): 
@@ -471 +471 @@
         return revPoly;
 }
+
+
+void Polygon3::Triangulate(vector<Triangle3> &triangles)
+{
+        int i = 1;
+        int j = 0;
+        int k = mVertices.size() - 1;
+        int count = 0;
+
+        while (i < k)
+        {
+                triangles.push_back(Triangle3(mVertices[i], mVertices[j], mVertices[k]));
+
+                if ((count ++) % 2)
+                        j = i ++;
+                else
+                        j = k --;
+        }
+}

trunk/VUT/GtpVisibilityPreprocessor/src/Polygon3.h

@@ -98 +98 @@
         int CastRay(const Ray &ray, float &t, const float nearestT);
 
-        
+        /** The polygon is triangulated.
+        */
+        void Triangulate(vector<Triangle3> &triangles);
+
         /** The piercing rays of the polygon are inherited by the child fragments
                 @parm front_piece the front fragment inheriting the front rays

trunk/VUT/GtpVisibilityPreprocessor/src/RssPreprocessor.cpp

@@ -692 +692 @@
 
         
-        totalSamples += rays.size();
-        rssSamples += vssRays.size();
+        totalSamples += (int)rays.size();
+        rssSamples += (int)vssRays.size();
 
         

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCell.cpp

@@ -23 +23 @@
 }
 
+
 const ObjectPvs &ViewCell::GetPvs() const
 {
@@ -33 +34 @@
 }
 
+
 int ViewCell::Type() const 
 { 
         return VIEW_CELL; 
 }
+
 
 void ViewCell::AddPassingRay(const Ray &ray, const int contributions)
@@ -54 +57 @@
         mVolume = volume;
 }
+
+
+void ViewCell::SetMesh(Mesh *mesh)
+{
+        mMesh = mesh;
+}
+
 
 void ViewCell::UpdateViewCellsStats(ViewCellsStatistics &vcStat)

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCell.h

@@ -116 +116 @@
         */
         void SetArea(float area);
+
+        /** Updates the view cell statstics for this particular view cell.
+        */
         virtual void UpdateViewCellsStats(ViewCellsStatistics &vcStat);
 
@@ -123 +126 @@
         /// Rays piercing this view cell.
         RayContainer mPiercingRays;
+
+        /** Sets the mesh for this view cell.
+        */
+        void SetMesh(Mesh *mesh);
 
 protected:

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -8 +8 @@
 #include "Ray.h"
 #include "AxisAlignedBox3.h"
+#include "Triangle3.h"
+
 #include <stack>
 
@@ -423 +425 @@
         app << "#N_INVALIDLEAVES (number of invalid leaves )\n" << invalidLeaves << endl;
 
+        app << "#N_RAYS (number of rays / leaf)\n" << AvgRays() << endl;
         //app << "#N_PVS: " << pvs << endl;
 
@@ -776 +779 @@
 
         // constrruct root node geometry
-        BspNodeGeometry *cell = new BspNodeGeometry();
-        ConstructGeometry(mRoot, *cell);
+        BspNodeGeometry *geom = new BspNodeGeometry();
+        ConstructGeometry(mRoot, *geom);
 
         BspTraversalData tData(mRoot, polys, 0, mRootCell, rays, 
-                                                   ComputePvsSize(*rays), cell->GetArea(), cell);
+                                                   ComputePvsSize(*rays), geom->GetArea(), geom);
 
         tStack.push(tData);
@@ -1809 +1812 @@
         // accumulate depth to compute average depth
         mStat.accumDepth += data.mDepth;
-        
+        // accumulate rays to compute rays /  leaf
+        mStat.accumRays += (int)data.mRays->size();
 
         if (data.mDepth >= mTermMaxDepth)
@@ -2196 +2200 @@
 }
 
-void BspTree::ConstructGeometry(BspNode *n, BspNodeGeometry &cell) const
-{
-        PolygonContainer polys;
-        ConstructGeometry(n, polys);
-        cell.mPolys = polys;
-}
-
-void BspTree::ConstructGeometry(BspViewCell *vc, PolygonContainer &cell) const
+void BspTree::ConstructGeometry(BspViewCell *vc, BspNodeGeometry &geom) const
 {
         vector<BspLeaf *> leaves = vc->mLeaves;
@@ -2210 +2207 @@
 
         for (it = leaves.begin(); it != it_end; ++ it)
-                ConstructGeometry(*it, cell);
-}
-
-
-void BspTree::ConstructGeometry(BspNode *n, PolygonContainer &cell) const
+                ConstructGeometry(*it, geom);
+}
+
+
+void BspTree::ConstructGeometry(BspNode *n, BspNodeGeometry &geom) const
 {
         vector<Plane3> halfSpaces;
@@ -2291 +2288 @@
                 
                 if (candidates[i])
-                        cell.push_back(candidates[i]);
+                        geom.mPolys.push_back(candidates[i]);
         }
 }
@@ -2299 +2296 @@
                                                    const bool onlyUnmailed) const
 {
-        PolygonContainer cell;
-
-        ConstructGeometry(n, cell);
+        BspNodeGeometry geom;
+        ConstructGeometry(n, geom);
 
         stack<BspNode *> nodeStack;
@@ -2319 +2315 @@
             if (node != n && (!onlyUnmailed || !node->Mailed()))
                         {
-                                // test all planes of current node if candidate really
-                                // is neighbour
-                                PolygonContainer neighborCandidate;
-                                ConstructGeometry(node, neighborCandidate);
+                                // test all planes of current node if neighbour 
+                                // candidate really is neighbour
+                                BspNodeGeometry candidateGeom;
+                                ConstructGeometry(node, candidateGeom);
                                 
                                 bool isAdjacent = true;
@@ -2328 +2324 @@
                                 {
                                         const int cf = 
-                                                Polygon3::ClassifyPlane(neighborCandidate, 
+                                                Polygon3::ClassifyPlane(candidateGeom.mPolys, 
                                                                                                 halfSpaces[i],
                                                                                                 mEpsilon);
@@ -2338 +2334 @@
                                 if (isAdjacent)
                                         neighbors.push_back(dynamic_cast<BspLeaf *>(node));
-
-                                CLEAR_CONTAINER(neighborCandidate);
                         }
                 }
@@ -2346 +2340 @@
                         BspInterior *interior = dynamic_cast<BspInterior *>(node);
         
-                        const int cf = Polygon3::ClassifyPlane(cell, 
+                        const int cf = Polygon3::ClassifyPlane(geom.mPolys, 
                                                                                                    interior->mPlane,
                                                                                                    mEpsilon);
@@ -2364 +2358 @@
         }
         
-        CLEAR_CONTAINER(cell);
         return (int)neighbors.size();
 }
+
 
 BspLeaf *BspTree::GetRandomLeaf(const Plane3 &halfspace)
@@ -2387 +2381 @@
                 {
                         BspInterior *interior = dynamic_cast<BspInterior *>(node);
-                        
                         BspNode *next;
         
-                        PolygonContainer cell;
-
+                        BspNodeGeometry geom;
                         // todo: not very efficient: constructs full cell everytime
-                        ConstructGeometry(interior, cell);
-
-                        const int cf = Polygon3::ClassifyPlane(cell, 
+                        ConstructGeometry(interior, geom);
+
+                        const int cf = Polygon3::ClassifyPlane(geom.mPolys, 
                                                                                                    halfspace, 
                                                                                                    mEpsilon);
@@ -2534 +2526 @@
 /*************************************************************/
 
+
 BspNodeGeometry::~BspNodeGeometry()
 {
         CLEAR_CONTAINER(mPolys);
 }
+
 
 float BspNodeGeometry::GetArea() const 
@@ -2543 +2537 @@
         return Polygon3::GetArea(mPolys);
 }
+
+
+void BspNodeGeometry::AddToMesh(Mesh &mesh)
+{
+        PolygonContainer::const_iterator it, it_end = mPolys.end();
+        int vcount = 0;
+
+        for (it = mPolys.begin(); it != mPolys.end(); ++ it)
+        {
+                Polygon3 *poly = *it;
+                
+                vector<Triangle3> triangles;
+                poly->Triangulate(triangles);
+                vector<Triangle3>::const_iterator tit, tit_end = triangles.end();
+        
+                for (tit = triangles.begin(); tit != tit_end; ++ tit)
+                {
+                        mesh.mVertices.push_back((*tit).mVertices[0]);
+                        mesh.mVertices.push_back((*tit).mVertices[1]);
+                        mesh.mVertices.push_back((*tit).mVertices[2]);
+
+                        Face *face = new Face(vcount ++, vcount ++, vcount ++);
+                        mesh.AddFace(face);
+                }
+        }
+}
+
 
 void BspNodeGeometry::SplitGeometry(BspNodeGeometry &front,

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.h

@@ -44 +44 @@
         */
         void ComputeBoundingBox(AxisAlignedBox3 &box);
+
         /** Splits the polygon and returns the part of the polygon inside of the node geometry.
         */
         Polygon3 *SplitPolygon(Polygon3 *poly, const float epsilon) const;
 
+        /** Adds node geometry to mesh.
+                @note the mesh vertices will not be connected
+        */
+        void AddToMesh(Mesh &mesh);
+
+        /** The polygons the geometry consists of.
+        */
         PolygonContainer mPolys;
 };
@@ -132 +140 @@
         /// polygon splits 
         int polySplits;
+        /// accumulated number of rays refs
+        int accumRays;
 
         // Constructor
@@ -145 +155 @@
         // TODO: computation wrong
         double AvgDepth() const { return accumDepth / (double)Leaves();}; 
-  
+        double AvgRays() const { return accumRays / (double)Leaves();}; 
+
         void Reset() 
         {
@@ -170 +181 @@
                 invalidLeaves = 0;
                 polySplits = 0;
+                accumRays = 0;
         }
 
@@ -458 +470 @@
                 @returns the number of intersections with objects stored in the tree.
         */
-  int
-  _CastRay(Ray &ray);
-
-
-  int
-  CastLineSegment(const Vector3 &origin,
-                                  const Vector3 &termination,
-                                  ViewCellContainer &viewcells
-                                  );
-
-  ViewCell *
-  GetViewCell(const Vector3 &point);
+        int     _CastRay(Ray &ray);
+
+
+        int     CastLineSegment(const Vector3 &origin,
+                                                const Vector3 &termination,
+                                                ViewCellContainer &viewcells
+                                                );
+
+        ViewCell *GetViewCell(const Vector3 &point);
   
         /// bsp tree construction types
@@ -483 +492 @@
                                           const bool onlyUnmailed) const;
 
-        /** Constructs geometry associated with the half space intersections 
-                leading to this node.
-        */
-        void ConstructGeometry(BspNode *n, PolygonContainer &cell) const;
+        /** Constructs geometry of view cell returning a BSP node geometry type.
+        */
+        void ConstructGeometry(BspNode *n, BspNodeGeometry &cell) const;
         
         /** Construct geometry of view cell.
         */
-        void ConstructGeometry(BspViewCell *vc, PolygonContainer &cell) const;
-
-        /** Constructs geometry of view cell returning a BSP node geometry type.
-        */
-        void ConstructGeometry(BspNode *n, BspNodeGeometry &cell) const;
+        void ConstructGeometry(BspViewCell *vc, BspNodeGeometry &geom) const;
 
         /** Returns random leaf of BSP tree.
@@ -788 +792 @@
         void AddToPvs(BspLeaf *leaf,
                                   const BoundedRayContainer &rays, 
-                                  int &sampleContributions,
+                                  int &sampleContributions,     
                                   int &contributingSamples);
 

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);
+}

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.h

@@ -25 +25 @@
 class ViewCellsStatistics;
 class Exporter;
+
 struct BspRay;
 
@@ -171 +172 @@
         virtual void GetPvsStatistics(PvsStatistics &stat);
 
-  /** Get a viewcell containing the specified point */
-  virtual ViewCell *GetViewCell(const Vector3 &point) = 0;
+        /** Get a viewcell containing the specified point */
+        virtual ViewCell *GetViewCell(const Vector3 &point) = 0;
   
-  virtual void
-  PrintPvsStatistics(ostream &s);
+        virtual void PrintPvsStatistics(ostream &s);
 
         /** Returns probability that view point lies in one view cell.
@@ -233 +233 @@
         void SetViewSpaceBox(const AxisAlignedBox3 &box);
 
+        /** Creates mesh for this view cell.
+        */
+        virtual void CreateMesh(ViewCell *vc) = NULL;
 
 protected:
@@ -265 +268 @@
         */
         virtual void ExportVcGeometry(Exporter *exporter, ViewCell *vc) const = 0;
+
+        /** Creates meshes from the view cells.
+        */
+        void CreateViewCellsMeshes();
 
         /// the view cell corresponding to space ouside the valid view space
@@ -291 +298 @@
         /// the scene bounding box
         AxisAlignedBox3 mSceneBox;
+
+        MeshContainer mMeshContainer;
 
         //-- visualization options
@@ -343 +352 @@
         AxisAlignedBox3 GetSceneBbox() const;
 
-  /** Get a viewcell containing the specified point */
-  ViewCell *GetViewCell(const Vector3 &point);
+        /** Get a viewcell containing the specified point */
+        ViewCell *GetViewCell(const Vector3 &point);
+
+        void CreateMesh(ViewCell *vc);
 
 protected:
@@ -411 +422 @@
         /** Prints out statistics of this approach.
         */
-  //  virtual void PrintStatistics(ostream &s) const;
-  ViewCell *GetViewCell(const Vector3 &point) { return NULL; }
-
-  float GetProbability(ViewCell *viewCell);
-  float GetRendercost(ViewCell *viewCell, float objRendercost) const;
+        //  virtual void PrintStatistics(ostream &s) const;
+        ViewCell *GetViewCell(const Vector3 &point) { return NULL; }
+
+        float GetProbability(ViewCell *viewCell);
+        float GetRendercost(ViewCell *viewCell, float objRendercost) const;
   
-  AxisAlignedBox3 GetSceneBbox() const;
+        AxisAlignedBox3 GetSceneBbox() const;
+
+        void CreateMesh(ViewCell *vc);
 
 protected:
@@ -468 +481 @@
                                                 ViewCellContainer &viewcells);
 
-  ViewCell *GetViewCell(const Vector3 &point) { return NULL; }
+        ViewCell *GetViewCell(const Vector3 &point) { return NULL; }
 
         float GetProbability(ViewCell *viewCell);
@@ -474 +487 @@
 
         AxisAlignedBox3 GetSceneBbox() const;
+
+        void CreateMesh(ViewCell *vc);
+
 protected:
 
@@ -526 +542 @@
         
         AxisAlignedBox3 GetSceneBbox() const;
-
-  ViewCell *GetViewCell(const Vector3 &point);
+        
+        ViewCell *GetViewCell(const Vector3 &point);
 
         bool GetViewPoint(Vector3 &viewPoint) const;
 
         bool ViewPointValid(const Vector3 &viewPoint) const;
+
+        void CreateMesh(ViewCell *vc);
+
 protected:
-        /** DEPRECATED
-        */
-        int MergeViewCells(const VssRayContainer &rays) const;
-
-        /** Returns true if front and back leaf should be merged.
-        */
-        bool ShouldMerge(BspLeaf *front, BspLeaf *back) const;
+
+        /** Merges the view cells.
+        */
+        void MergeViewCells(const VssRayContainer &rays, const ObjectContainer &objects);
+        
+        void RefineViewCells(const VssRayContainer &rays);
 
         void CollectViewCells();

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp

@@ -835 +835 @@
 
 
+/*
 float VspBspTree::EvalCostRatio(const VspBspTraversalData &tData,
                                                                 const AxisAlignedBox3 &box,
@@ -949 +950 @@
         return  (mCtDivCi + newCost) / oldCost;
 }
-
+*/
 
 
@@ -1304 +1305 @@
 
 
-void VspBspTree::CollectLeaves(vector<BspLeaf *> &leaves) const
+void VspBspTree::CollectLeaves(vector<BspLeaf *> &leaves, 
+                                                           const bool onlyUnmailed,
+                                                           const int maxPvsSize) const
 {
         stack<BspNode *> nodeStack;
@@ -1317 +1320 @@
                 {
                         // test if this leaf is in valid view space
-                        if (node->TreeValid())
+                        BspLeaf *leaf = dynamic_cast<BspLeaf *>(node);
+                        if (leaf->TreeValid() && 
+                                (!onlyUnmailed || leaf->Mailed()) &&
+                                ((maxPvsSize < 0) || (leaf->GetViewCell()->GetPvs().GetSize() <= maxPvsSize)))
                         {
-                                BspLeaf *leaf = (BspLeaf *)node;
                                 leaves.push_back(leaf);
                         }
@@ -1641 +1646 @@
 
 void VspBspTree::ConstructGeometry(BspNode *n,
-                                                                   BspNodeGeometry &cell) const
-{
-        ConstructGeometry(n, cell.mPolys);
-}
-
-
-void VspBspTree::ConstructGeometry(BspNode *n,
-                                                                   PolygonContainer &cell) const
+                                                                   BspNodeGeometry &geom) const
 {
         vector<Plane3> halfSpaces;
@@ -1726 +1724 @@
 
                 if (candidatePolys[i])
-                        cell.push_back(candidatePolys[i]);
+                        geom.mPolys.push_back(candidatePolys[i]);
         }
 }
@@ -1732 +1730 @@
 
 void VspBspTree::ConstructGeometry(BspViewCell *vc, 
-                                                                   PolygonContainer &vcGeom) const
+                                                                   BspNodeGeometry &vcGeom) const
 {
         vector<BspLeaf *> leaves = vc->mLeaves;
@@ -1745 +1743 @@
                                                    const bool onlyUnmailed) const
 {
-        PolygonContainer geom;
+        BspNodeGeometry geom;
         ConstructGeometry(n, geom);
 
@@ -1770 +1768 @@
                                 // test all planes of current node if candidate really
                                 // is neighbour
-                                PolygonContainer neighborCandidate;
+                                BspNodeGeometry neighborCandidate;
                                 ConstructGeometry(node, neighborCandidate);
 
@@ -1777 +1775 @@
                                 {
                                         const int cf =
-                                                Polygon3::ClassifyPlane(neighborCandidate,
+                                                Polygon3::ClassifyPlane(neighborCandidate.mPolys,
                                                                                                 halfSpaces[i],
                                                                                                 mEpsilon);
@@ -1787 +1785 @@
                                 if (isAdjacent)
                                         neighbors.push_back(dynamic_cast<BspLeaf *>(node));
-
-                                CLEAR_CONTAINER(neighborCandidate);
                         }
                 }
@@ -1795 +1791 @@
                         BspInterior *interior = dynamic_cast<BspInterior *>(node);
 
-                        const int cf = Polygon3::ClassifyPlane(geom,
+                        const int cf = Polygon3::ClassifyPlane(geom.mPolys,
                                                                                                    interior->GetPlane(),
                                                                                                    mEpsilon);
@@ -1813 +1809 @@
         }
 
-        CLEAR_CONTAINER(geom);
         return (int)neighbors.size();
 }
@@ -1837 +1832 @@
                 {
                         BspInterior *interior = dynamic_cast<BspInterior *>(node);
-
                         BspNode *next;
-
-                        PolygonContainer geom;
+                        BspNodeGeometry geom;
 
                         // todo: not very efficient: constructs full cell everytime
                         ConstructGeometry(interior, geom);
 
-                        const int cf = Polygon3::ClassifyPlane(geom, halfspace, mEpsilon);
+                        const int cf = 
+                                Polygon3::ClassifyPlane(geom.mPolys, halfspace, mEpsilon);
 
                         if (cf == Polygon3::BACK_SIDE)
@@ -2248 +2242 @@
 
 
-int VspBspTree::CollectMergeCandidates()
-{
-        vector<BspLeaf *> leaves;
-
-        // collect the leaves, e.g., the "voxels" that will build the view cells
-        CollectLeaves(leaves);
+int VspBspTree::CollectMergeCandidates(const vector<BspLeaf *> leaves)
+{
         BspLeaf::NewMail();
 
@@ -2291 +2281 @@
         vector<BspRay *> bspRays;
 
+        long startTime = GetTime();
         ConstructBspRays(bspRays, rays);
+        Debug << (int)bspRays.size() << " bsp rays constructed in " << TimeDiff(startTime, GetTime()) * 1e-3f << " secs" << endl;
+
         map<BspLeaf *, vector<BspLeaf*> > neighborMap;
-
         vector<BspIntersection>::const_iterator iit;
 
-        int leaves = 0;
+        int numLeaves = 0;
         
         BspLeaf::NewMail();
@@ -2321 +2313 @@
                                 leaf->mArea * leaf->mPvs->GetSize();
                         
-                        ++ leaves;
+                        ++ numLeaves;
                 }
                 
@@ -2345 +2337 @@
                                         leaf->mArea * leaf->mPvs->GetSize();
 
-                                ++ leaves;
+                                ++ numLeaves;
                         }
                 
@@ -2379 +2371 @@
         Debug << "neighbormap size: " << (int)neighborMap.size() << endl;
         Debug << "mergequeue: " << (int)mMergeQueue.size() << endl;
-        Debug << "leaves in queue: " << leaves << endl;
+        Debug << "leaves in queue: " << numLeaves << endl;
         Debug << "overall cost: " << BspMergeCandidate::sOverallCost << endl;
 
         CLEAR_CONTAINER(bspRays);
 
-        return leaves;
+        //-- collect the leaves which haven't been found by ray casting
+        vector<BspLeaf *> leaves;
+        CollectLeaves(leaves, true, mMaxPvs);
+        Debug << "found " << (int)leaves.size() << " new leaves" << endl;
+        //CollectMergeCandidates(leaves);
+
+        return numLeaves;
 }
 
@@ -2440 +2438 @@
                 mergeStats.nodes = CollectMergeCandidates(rays);
         else
-                mergeStats.nodes = CollectMergeCandidates();
+        {
+                vector<BspLeaf *> leaves;
+                CollectLeaves(leaves);
+                mergeStats.nodes = CollectMergeCandidates(leaves);
+        }
 
         mergeStats.collectTime = TimeDiff(startTime, GetTime());
@@ -2735 +2737 @@
 }
 
+#define USE_ASCII 0
+bool VspBspTree::WriteVspBspTree()
+{
+        char fileName[100];
+        environment->GetStringValue("VspBspTree.viewCellsFilename", fileName);
+        
+        /*VssRayContainer::const_iterator it, it_end = samples.end();
+        
+#if USE_ASCII
+        ofstream samplesOut(fileName);
+        if (!samplesOut.is_open())
+                return false;
+
+        for (it = samples.begin(); it != it_end; ++ it)
+        {
+                VssRay *ray = *it;
+                int sourceid = ray->mOriginObject ? ray->mOriginObject->mId : -1;               
+                int termid = ray->mTerminationObject ? ray->mTerminationObject->mId : -1;       
+
+                samplesOut << ray->GetOrigin().x << " " << ray->GetOrigin().y << " " << ray->GetOrigin().z << " " 
+                                   << ray->GetTermination().x << " " << ray->GetTermination().y << " " << ray->GetTermination().z << " " 
+                                   << sourceid << " " << termid << "\n";
+        }
+#else
+        ofstream samplesOut(fileName, ios::binary);
+        if (!samplesOut.is_open())
+                return false;
+
+        for (it = samples.begin(); it != it_end; ++ it)
+        {       
+                VssRay *ray = *it;
+                Vector3 origin(ray->GetOrigin());
+                Vector3 termination(ray->GetTermination());
+                
+                int sourceid = ray->mOriginObject ? ray->mOriginObject->mId : -1;               
+                int termid = ray->mTerminationObject ? ray->mTerminationObject->mId : -1;               
+
+                samplesOut.write(reinterpret_cast<char *>(&origin), sizeof(Vector3));
+                samplesOut.write(reinterpret_cast<char *>(&termination), sizeof(Vector3));
+                samplesOut.write(reinterpret_cast<char *>(&sourceid), sizeof(int));
+                samplesOut.write(reinterpret_cast<char *>(&termid), sizeof(int));
+    }
+#endif
+
+        samplesOut.close();
+        */
+        return true;
+}
+
+bool VspBspTree::LoadVspBspTree()
+{
+        /*std::stable_sort(objects.begin(), objects.end(), ilt);
+        char fileName[100];
+        environment->GetStringValue("Preprocessor.samplesFilename", fileName);
+        
+    Vector3 origin, termination;
+        // HACK: needed only for lower_bound algorithm to find the 
+        // intersected objects
+        MeshInstance sObj(NULL);
+        MeshInstance tObj(NULL);
+
+#if USE_ASCII
+        ifstream samplesIn(fileName, ios::binary);
+        if (!samplesIn.is_open())
+                return false;
+
+        string buf;
+        while (!(getline(samplesIn, buf)).eof())
+        {
+                sscanf(buf.c_str(), "%f %f %f %f %f %f %d %d", 
+                           &origin.x, &origin.y, &origin.z,
+                           &termination.x, &termination.y, &termination.z, 
+                           &(sObj.mId), &(tObj.mId));
+                
+                Intersectable *sourceObj = NULL;
+                Intersectable *termObj = NULL;
+                
+                if (sObj.mId >= 0)
+                {
+                        ObjectContainer::iterator oit =
+                                lower_bound(objects.begin(), objects.end(), &sObj, ilt);
+                        sourceObj = *oit;
+                }
+                
+                if (tObj.mId >= 0)
+                {
+                        ObjectContainer::iterator oit =
+                                lower_bound(objects.begin(), objects.end(), &tObj, ilt);
+                        termObj = *oit;
+                }
+
+                samples.push_back(new VssRay(origin, termination, sourceObj, termObj));
+        }
+#else
+        ifstream samplesIn(fileName, ios::binary);
+        if (!samplesIn.is_open())
+                return false;
+
+        while (1)
+        {
+                 samplesIn.read(reinterpret_cast<char *>(&origin), sizeof(Vector3));
+                 samplesIn.read(reinterpret_cast<char *>(&termination), sizeof(Vector3));
+                 samplesIn.read(reinterpret_cast<char *>(&(sObj.mId)), sizeof(int));
+                 samplesIn.read(reinterpret_cast<char *>(&(tObj.mId)), sizeof(int));
+                
+                 if (samplesIn.eof())
+                        break;
+
+                Intersectable *sourceObj = NULL;
+                Intersectable *termObj = NULL;
+                
+                if (sObj.mId >= 0)
+                {
+                        ObjectContainer::iterator oit =
+                                lower_bound(objects.begin(), objects.end(), &sObj, ilt);
+                        sourceObj = *oit;
+                }
+                
+                if (tObj.mId >= 0)
+                {
+                        ObjectContainer::iterator oit =
+                                lower_bound(objects.begin(), objects.end(), &tObj, ilt);
+                        termObj = *oit;
+                }
+
+                samples.push_back(new VssRay(origin, termination, sourceObj, termObj));
+        }
+
+#endif
+        samplesIn.close();
+*/
+        return true;
+}
+
 
 /************************************************************************/

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.h

@@ -56 +56 @@
                 /// how often this branch has missed the max-cost ratio
                 int mMaxCostMisses;
-
-
+        
                 /** Returns average ray contribution.
                 */
@@ -164 +163 @@
                                    AxisAlignedBox3 *forcedBoundingBox);
 
-        /** Returns list of BSP leaves.
-        */
-        void CollectLeaves(vector<BspLeaf *> &leaves) const;
+        /** Returns list of BSP leaves with pvs smaller than
+                a certain threshold.
+                @param onlyUnmailed if only the unmailed leaves should be considered
+                @param maxPvs the maximal pvs (-1 means unlimited)
+        */
+        void CollectLeaves(vector<BspLeaf *> &leaves, 
+                                           const bool onlyUnmailed = false,
+                                           const int maxPvs = -1) const;
 
         /** Returns box which bounds the whole tree.
@@ -203 +207 @@
                 leading to this node.
         */
-        void ConstructGeometry(BspNode *n, PolygonContainer &cell) const;
-
-        /** Constructs geometry associated with the half space intersections 
-                leading to this node.
-        */
-        void ConstructGeometry(BspViewCell *vc, PolygonContainer &cell) const;
-
-        /** Construct geometry and stores it in a geometry node container.
-        */
-        void ConstructGeometry(BspNode *n, BspNodeGeometry &cell) const;
+        void ConstructGeometry(BspNode *n, BspNodeGeometry &geom) const;
+        
+        /** Construct geometry of view cell.
+        */
+        void ConstructGeometry(BspViewCell *vc, BspNodeGeometry &geom) const;
 
         /** Returns random leaf of BSP tree.
@@ -284 +283 @@
         */
         BspViewCell *GetOutOfBoundsCell() const;
+
+        /** Writes tree to disc.
+        */
+        bool WriteVspBspTree();
+
+        /** Loads tree from disc.
+        */
+        bool LoadVspBspTree();
 
 protected:
@@ -457 +464 @@
         /** Evaluates cost ratio for axis aligned splits.
         */
-        float EvalCostRatio(const VspBspTraversalData &tData,
+        /*float EvalCostRatio(const VspBspTraversalData &tData,
                                                 const AxisAlignedBox3 &box,
                                                 const int axis,
@@ -464 +471 @@
                                                 int &raysFront,
                                                 int &pvsBack,
-                                                int &pvsFront);
+                                                int &pvsFront);*/
 
         /** Selects an axis aligned split plane.
@@ -542 +549 @@
 
         /** Collects candidates for the merge in the merge queue.
+                @param leaves the leaves to be merged
                 @returns number of leaves in queue
         */
-        int CollectMergeCandidates();
+        int CollectMergeCandidates(const vector<BspLeaf *> leaves);
         /** Collects candidates for the merge in the merge queue.
                 @returns number of leaves in queue

trunk/VUT/GtpVisibilityPreprocessor/src/VspKdTree.cpp

@@ -2007 +2007 @@
         }
 }
+
 
 int VspKdTree::FindNeighbors(VspKdLeaf *n,

trunk/VUT/GtpVisibilityPreprocessor/src/X3dExporter.cpp

@@ -964 +964 @@
         for (it = leaves.begin(); it != it_end; ++ it)
         {
-                PolygonContainer cell;
-                tree.ConstructGeometry(*it, cell);
+                BspNodeGeometry geom;
+                tree.ConstructGeometry(*it, geom);
                 
-                ExportPolygons(cell);
-
-                CLEAR_CONTAINER(cell);
+                ExportPolygons(geom.mPolys);
         }
 }