Changeset 441

Timestamp:

12/01/05 18:50:06 (19 years ago)

Author:

mattausch

Message:

added visibilitymanager
removed area computation from bsp

Location:

trunk/VUT/GtpVisibilityPreprocessor

Files:

• scripts/default.env (modified) (5 diffs)
• src/Environment.cpp (modified) (2 diffs)
• src/Preprocessor.cpp (modified) (2 diffs)
• src/Ray.cpp (modified) (1 diff)
• src/RenderSimulator.h (modified) (1 diff)
• src/SamplingPreprocessor.cpp (modified) (12 diffs)
• src/SamplingPreprocessor.h (modified) (2 diffs)
• src/ViewCellBsp.cpp (modified) (29 diffs)
• src/ViewCellBsp.h (modified) (9 diffs)
• src/ViewCellsManager.cpp (modified) (24 diffs)
• src/ViewCellsManager.h (modified) (10 diffs)
• src/VspBspTree.cpp (modified) (13 diffs)
• src/VspBspTree.h (modified) (5 diffs)
• src/VssRay.h (modified) (1 diff)

trunk/VUT/GtpVisibilityPreprocessor/scripts/default.env

@@ -19 +19 @@
 
 Preprocessor {
-#       type sampling
-        type vss
+        type sampling
+#       type vss
 }
 
@@ -99 +99 @@
 
 ViewCells {
-        #hierarchy kdTree
-        #hierarchy vspTree
-        hierarchy bspTree
-        #hierarchy sceneDependent
+        loadFromFile false
+        #type kdTree
+        #type vspTree
+        type bspTree
+        #type sceneDependent
         
         height 5.0
@@ -123 +124 @@
 BspTree {
         Construction {
-                input fromSamples
-        #       input fromViewCells
-        #       input fromSceneGeometry
-                samples 50000
+                samples 200000
                 sideTolerance 0.005
         }
@@ -169 +167 @@
         maxRayCandidates 50
         
+        maxTests 500
+        
         # factors for evaluating split plane costs
         Factor {
@@ -186 +186 @@
                 minRays 300
                 minPolygons -1
-                maxDepth 20
-                minPvs 400
+                maxDepth 40
+                minPvs 200
                 minArea 0.01
                 maxRayContribution 0.005

trunk/VUT/GtpVisibilityPreprocessor/src/Environment.cpp

@@ -1175 +1175 @@
                                                                  "true");
 
-  RegisterOption("ViewCells.hierarchy",
+  RegisterOption("ViewCells.type",
                  optString,
-                 "-view_cells_hierarchy",
+                 "-view_cells_type",
                  "bspTree");
+
+   RegisterOption("ViewCells.loadFromFile",
+                 optBool,
+                 "-view_cells_load_from_file",
+                 "false");
 
   RegisterOption("ViewCells.maxViewCells",
@@ -1329 +1334 @@
           "-bsp_max_plane_candidates=",
           "20");
+
+  RegisterOption("BspTree.maxTests",
+          optInt,
+          "-bsp_max_tests=",
+          "5000");
 
   RegisterOption("BspTree.Visualization.samples",

trunk/VUT/GtpVisibilityPreprocessor/src/Preprocessor.cpp

@@ -175 +175 @@
                 int bspConstructionSamples = 0;
 
+                mBspTree = new BspTree();
+
                 environment->GetIntValue("BspTree.Construction.samples", bspConstructionSamples);
                 mViewCellsManager = new BspViewCellsManager(mBspTree, bspConstructionSamples);
@@ -212 +214 @@
 
         bool loadViewCells = false;
-        environment->GetBoolValue("ViewCell.Construction.loadFromFile", loadViewCells);
+        environment->GetBoolValue("ViewCells.loadFromFile", loadViewCells);
 
         //-- load view cells from file if requested

trunk/VUT/GtpVisibilityPreprocessor/src/Ray.cpp

@@ -229 +229 @@
                 dir = vssRay.GetDir() / dist;
 
-        intersections.push_back(Intersection(dist, vssRay.mTerminationObject, 0));
+        if (vssRay.mTerminationObject)
+                intersections.push_back(Intersection(dist, vssRay.mTerminationObject, 0));
 
         Precompute();

trunk/VUT/GtpVisibilityPreprocessor/src/RenderSimulator.h

@@ -37 +37 @@
                 return s;
         }  
+
+        SimulationStatistics()
+        {
+                Reset();
+        }
 };
 

trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.cpp

@@ -27 +27 @@
 void
 SamplingPreprocessor::SetupRay(Ray &ray, 
-                                                                                                                         const Vector3 &point, 
-                                                                                                                         const Vector3 &direction,
+                                                           const Vector3 &point, 
+                                                           const Vector3 &direction,
                                                            const int type,
                                                            const Ray::Intersection &origin)
@@ -57 +57 @@
 
  
-int
+void
 SamplingPreprocessor::CastRays(const RayContainer &rays, 
                                                            int &sampleContributions, 
                                                            int &contributingSamples)
-        {       
+{       
         // cast ray to KD tree to find intersection with other objects
         RayContainer::const_iterator it, it_end = rays.end();
  
         for (it = rays.begin(); it != it_end; ++it)
-        mKdTree->CastRay((*it));
-
-        sampleContributions = mViewCellsManager->CastRays(rays);
+        mKdTree->CastRay(*(*it));
+
+        // for KD tree, intersecting view cells are already known, so no 
+        // additional ray must be cast to them
+        const bool castRaysToViewCells = 
+                (mViewCellsManager->GetType() != ViewCellsManager::KD);
+
+        mViewCellsManager->ComputeSampleContributions(rays, 
+                                                                                                  castRaysToViewCells,
+                                                                                                  sampleContributions, 
+                                                                                                  contributingSamples);
 }
 
 int
-SamplingPreprocessor::CastRay(const Ray &ray)
+SamplingPreprocessor::CastRay(Ray &ray)
 {
         // cast ray to KD tree to find intersection with other objects
         mKdTree->CastRay(ray);
 
-        return mViewCellsManager->CastRay(ray);
+        bool castRayToViewCells = mViewCellsManager->GetType() != ViewCellsManager::KD;
+
+        return mViewCellsManager->ComputeSampleContributions(ray, castRayToViewCells);
 }
 
@@ -134 +144 @@
 int
 SamplingPreprocessor::CastEdgeSamples(
-                                                                                                                                                        Intersectable *object,
-                                                                                                                                                        const Vector3 &point,
-                                                                                                                                                        MeshInstance *mi,
-                                                                                                                                                        const int samples
-                                                                                                                                                        )
+                                                                          Intersectable *object,
+                                                                          const Vector3 &point,
+                                                                          MeshInstance *mi,
+                                                                          const int samples
+                                                                          )
 {
         Ray ray;
@@ -156 +166 @@
                 float t = RandomValue(0.0f,1.0f);
                 Vector3 target = t*poly.mVertices[edge] + (1.0f-t)*poly.mVertices[(edge + 1)%
-                                                                                                                                                                                                                                                                                 poly.mVertices.size()];
+                        poly.mVertices.size()];
                 SetupRay(ray, point, target - point, Ray::LOCAL_RAY, Ray::Intersection(0, object, 0));
                 if (!mesh->CastRay(ray, mi)) {
@@ -288 +298 @@
                                 for (int k=0; k < mSamplesPerPass; k++) {
                                         bool reverseSample = false;
-                                        
-
+                                
                                         if (nodeToSample) {
                                                 AxisAlignedBox3 box = mKdTree->GetBox(nodeToSample);
@@ -313 +322 @@
                                         Ray::Intersection source = 
                                                 Ray::Intersection(0, reverseSample ? NULL : object, faceIndex);
-                                        
+                        
                                         // construct a ray
                                         SetupRay(*ray, point, direction, Ray::LOCAL_RAY, source);
@@ -323 +332 @@
                                                 passSampleContributions += sampleContributions;
                                         }*/
-                
-                                        //-------------------
-                                        ProcessViewCells(ray,
-                                                                         objects,
-                                                                         passContributingSamples,
-                                                                         passSampleContributions);
                                 }
                         } else {
@@ -340 +343 @@
                 }
         
-                CastRays(passRays, passSampleContributions, passContributingSamples);
+                //-------------------
+                // cast rays for view cells construction
+                ProcessViewCells(passRays,
+                                                 objects,
+                                                 passSampleContributions,
+                                                 passContributingSamples);
+
                 CLEAR_CONTAINER(passRays);
-                passRays.clear();
-
+                
                 totalSamples += passSamples; 
                 
@@ -349 +357 @@
                 //      HoleSamplingPass();
     
-                mPass++;
+                mPass ++;
         
-                        pvsSize += passSampleContributions;
+                pvsSize += passSampleContributions;
                 
                 float avgRayContrib = (passContributingSamples > 0) ? 
@@ -393 +401 @@
         cout << "\nevaluating bsp view cells render time before merge ... ";
                  
-        SimulationStatistics ss = mViewCellsManager->SimulateRendering();
+        const SimulationStatistics ss = mViewCellsManager->SimulateRendering();
                  
         cout << " finished" << endl;
@@ -400 +408 @@
                  
         mViewCellsManager->Visualize(objects, mSampleRays);     
-  
-  return true;
-}
-
-void SamplingPreprocessor::ProcessViewCells(const Ray &ray,
+    
+        return true;
+}
+
+void SamplingPreprocessor::ProcessViewCells(const RayContainer &newRays,
                                                                                         const ObjectContainer &objects,
-                                                                                        int &contributingSamples,
-                                                                                        int &sampleContributions)
-{
+                                                                                        int &sampleContributions,
+                                                                                        int &contributingSamples)
+{
+        // cast rays to view cells
+        CastRays(newRays, sampleContributions, contributingSamples);
+
         // save rays for view cells construction
         if (!mViewCellsManager->ViewCellsConstructed())
+        {
+                RayContainer::const_iterator it, it_end = newRays.end();
+
+                if ((int)mVssSampleRays.size() < mViewCellsManager->GetConstructionSamples())
                 {
-                if ((int)mSampleRays.size() < mViewCellsManager->GetConstructionSamples())
-                        mVssSampleRays.push_back(new VssRay(ray));
+                        for (it = newRays.begin(); it != it_end; ++ it)
+                                mVssSampleRays.push_back(new VssRay(*(*it)));
+                }
                 else
                 {
                         mViewCellsManager->Construct(objects, mVssSampleRays);
+        
                         // construct view cells using the collected samples
                         cout << "building view cells from " << (int)mSampleRays.size() << " samples " << endl;
@@ -432 +449 @@
                          ((int)mSampleRays.size() < mViewCellsManager->GetVisualizationSamples()))
         {
-                mSampleRays.push_back(new Ray(ray));
-        }
-}
+                RayContainer::const_iterator it, it_end = newRays.end();
+
+                for (it = newRays.begin(); it != it_end; ++ it)
+                                mSampleRays.push_back(new Ray(*(*it)));
+        }
+}

trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.h

@@ -37 +37 @@
 
         /** Casts a bundle of sample rays into the scene.
+                @param sampleContributions the number of sample contributions
+                @param contributingSamples the number of samples contributing
         */
-        int CastRays(const RayContainer &rays,
-                                 int &sampleContribtion, 
-                                 int &contributingSamples);
+        void
+        CastRays(const RayContainer &rays,
+                         int &sampleContributions, 
+                         int &contributingSamples);
         
-        /** Casts a ray into the scene.
+        /** Casts a single ray into the scene.
+                @returns sample contributions
         */
-        int
-        CastRay(const Ray &ray);
+        int CastRay(Ray &ray);
         
         /** Verify if the exact visibility for this object was established.
@@ -55 +58 @@
                 along the visibility skeleton.
         */
-        int CastEdgeSamples(
-                                                                        Intersectable *object,
-                                                                        const Vector3 &point,
-                                                                        MeshInstance *mi,
-                                                                        const int samples
-                                                                        );
+        int 
+        CastEdgeSamples(
+                                        Intersectable *object,
+                                        const Vector3 &point,
+                                        MeshInstance *mi,
+                                        const int samples
+                                        );
 
         /** Processes the view cells during a pass.
-                @param ray the current ray
-
+                @param newRays the newly cast rays
+                @param sampleContributions returns the accumulated contribution of the samples
                 @param contributingSamples returns the samples contributing to pvs
-                @param sampleContributions returns the accumulated 
-                contribution of the samples
-*/
+        */
         
-        void ProcessViewCells(const Ray &ray,
+        void ProcessViewCells(const RayContainer &newRays,
                                                   const ObjectContainer &objects,
-                                                  int &contributingSamples,
-                                                  int &sampleContributions);
+                                                  int &sampleContributions,
+                                                  int &contributingSamples);
 
         /** Adds objects samples to kd and bsp view cells.

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -263 +263 @@
 /****************************************************************/
 
-BspTree::BspTree(BspViewCell *viewCell): 
-mRootCell(viewCell), 
+BspTree::BspTree():  
 mRoot(NULL), 
 mStoreLeavesWithRays(false),
-mPvsUseArea(true),
+mPvsUseLen(false),
 mGenerateViewCells(true)
 {
         Randomize(); // initialise random generator for heuristics
+
+        // the view cell corresponding to unbounded space
+        mRootCell = new BspViewCell();
 
         //-- termination criteria for autopartition
@@ -307 +309 @@
         environment->GetIntValue("BspTree.splitPlaneStrategy", mSplitPlaneStrategy);
         environment->GetFloatValue("BspTree.AxisAligned.splitBorder", mSplitBorder);
+        environment->GetIntValue("BspTree.maxTests", mMaxTests);
 
         environment->GetFloatValue("BspTree.Construction.sideTolerance", Vector3::sDistTolerance);
         Vector3::sDistToleranceSqrt = Vector3::sDistTolerance * Vector3::sDistTolerance;
 
-        // post processing stuff
-        environment->GetIntValue("ViewCells.PostProcessing.minPvsDif", mMinPvsDif);
-        environment->GetIntValue("ViewCells.PostProcessing.minPvs", mMinPvs);
-        environment->GetIntValue("ViewCells.PostProcessing.maxPvs", mMaxPvs);
 
     Debug << "BSP max depth: " << mTermMaxDepth << endl;
@@ -410 +409 @@
 {
         DEL_PTR(mRoot);
+        DEL_PTR(mRootCell);
+}
+
+BspViewCell *BspTree::GetRootCell() const
+{
+        return mRootCell;
 }
 
@@ -433 +438 @@
                 mRoot = new BspLeaf();
 
-        tStack.push(BspTraversalData(mRoot, polys, 0, mRootCell, new BoundedRayContainer(), 0, 
-                                                                 mBox.SurfaceArea(), new BspNodeGeometry()));
+        tStack.push(BspTraversalData(mRoot, polys, 0, mRootCell, 
+                new BoundedRayContainer(), 0));
 
         while (!tStack.empty())
@@ -470 +475 @@
                                                                                    mRootCell,   
                                                                                    tData.mRays,
-                                                                                   tData.mPvs,
-                                                                                   mBox.SurfaceArea(),
-                                                                                   new BspNodeGeometry());
+                                                                                   tData.mPvs);
 
                                 BspTraversalData backData(interior->GetBack(), 
@@ -479 +482 @@
                                                                                   mRootCell,    
                                                                                   tData.mRays,
-                                                                                  tData.mPvs,
-                                                                                  mBox.SurfaceArea(),
-                                                                                  new BspNodeGeometry());
+                                                                                  tData.mPvs);
 
                                 if (!mGenerateViewCells)
@@ -735 +736 @@
 
         BspTraversalData tData(mRoot, polys, 0, mRootCell, rays, 
-                                                   ComputePvsSize(*rays), cell->GetArea(), cell);
+                                                   ComputePvsSize(*rays));
 
         tStack.push(tData);
@@ -755 +756 @@
         }
 
+        Debug << "here2" << endl;
         cout << "finished\n";
 
@@ -766 +768 @@
                  ((int)data.mRays->size() <= mTermMinRays) ||
                  (data.mPvs <= mTermMinPvs) ||
-                 (data.mArea <= mTermMinArea) ||
                  (data.mDepth >= mTermMaxDepth) ||
                  (data.GetAvgRayContribution() < mTermMaxRayContribution));
@@ -815 +816 @@
                 DEL_PTR(tData.mPolygons);
                 DEL_PTR(tData.mRays);
-                DEL_PTR(tData.mGeometry);
-                
+                        
                 return leaf;
         }
@@ -824 +824 @@
         
         BspTraversalData tFrontData(NULL, new PolygonContainer(), tData.mDepth + 1, mRootCell, 
-                                                                new BoundedRayContainer(), 0, 0, new BspNodeGeometry());
+                                                                new BoundedRayContainer(), 0);
         BspTraversalData tBackData(NULL, new PolygonContainer(), tData.mDepth + 1, mRootCell, 
-                                                           new BoundedRayContainer(), 0, 0, new BspNodeGeometry());
+                                                           new BoundedRayContainer(), 0);
 
         // create new interior node and two leaf nodes
@@ -860 +860 @@
         DEL_PTR(tData.mPolygons);
         DEL_PTR(tData.mRays);
-        DEL_PTR(tData.mGeometry);               
-
+        
         return interior;
 }
@@ -901 +900 @@
         
         BspLeaf *leaf = dynamic_cast<BspLeaf *>(tData.mNode);
+
+        Debug << "*********************" << endl;
+        long startTime = GetTime();
+        
         // select subdivision plane
         BspInterior *interior = 
                 new BspInterior(SelectPlane(leaf, tData)); 
-
+        Debug << "time used for split plane selection: " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
 #ifdef _DEBUG
         Debug << interior << endl;
 #endif
         
+
+        Debug << "number of rays: " << tData.mRays->size() << endl;
+        Debug << "number of polys: " << tData.mPolygons->size() << endl;
+
+        startTime = GetTime();
+        
         // subdivide rays into front and back rays
         SplitRays(interior->mPlane, *tData.mRays, *frontData.mRays, *backData.mRays);
         
+        Debug << "time used for rays splitting: " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
+
+        startTime = GetTime();
         // subdivide polygons with plane
         mStat.splits += interior->SplitPolygons(*tData.mPolygons, 
@@ -918 +930 @@
                                                                                         coincident);
 
+        Debug << "time used for polygon splitting: " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
+
     // compute pvs
         frontData.mPvs = ComputePvsSize(*frontData.mRays);
         backData.mPvs = ComputePvsSize(*backData.mRays);
-
-        // split geometry and compute area
-        if (1)
-        {
-                tData.mGeometry->SplitGeometry(*frontData.mGeometry, 
-                                                                           *backData.mGeometry, 
-                                                                           *this, 
-                                                                           interior->mPlane);
-        
-                
-                frontData.mArea = frontData.mGeometry->GetArea();
-                backData.mArea = backData.mGeometry->GetArea();
-        }
 
         // compute accumulated ray length
@@ -1308 +1309 @@
         const int frontAndBackId = ViewCell::sMailId;
 
-        PolygonContainer::const_iterator it, it_end = polys.end();
-
-        for (it = polys.begin(); it != it_end; ++ it)
-        {
-                const int classification = (*it)->ClassifyPlane(candidatePlane);
+        bool useRand;;
+        int limit;
+
+        // choose test polyongs randomly if over threshold
+        if ((int)polys.size() > mMaxTests)
+        {
+                useRand = true;
+                limit = mMaxTests;
+        }
+        else
+        {
+                useRand = false;
+                limit = (int)polys.size();
+        }
+        
+
+        for (int i = 0; i < limit; ++ i)
+        {
+                const int testIdx = useRand ? Random(limit) : i;
+
+                Polygon3 *poly = polys[testIdx];
+
+        const int classification = poly->ClassifyPlane(candidatePlane);
 
                 if (mSplitPlaneStrategy & BALANCED_POLYS)
@@ -1323 +1342 @@
                 {
                         if (classification == Polygon3::COINCIDENT)
-                                sumPolyArea += (*it)->GetArea();
+                                sumPolyArea += poly->GetArea();
                         //totalArea += area;
                 }
@@ -1329 +1348 @@
                 if (mSplitPlaneStrategy & BLOCKED_RAYS)
                 {
-                        const float blockedRays = (float)(*it)->mPiercingRays.size();
+                        const float blockedRays = (float)poly->mPiercingRays.size();
                 
                         if (classification == Polygon3::COINCIDENT)
@@ -1340 +1359 @@
                 if (mSplitPlaneStrategy & BALANCED_VIEW_CELLS)
                 {
-                        MeshInstance *viewCell = (*it)->mParent;
+                        MeshInstance *viewCell = poly->mParent;
                 
                         // assure that we only count a view cell 
@@ -1434 +1453 @@
 float BspTree::SplitPlaneCost(const Plane3 &candidatePlane, 
                                                           const BoundedRayContainer &rays,
-                                                          const int pvs,
-                                                          const float area,
-                                                          const BspNodeGeometry &cell) const
+                                                          const int pvs) const
 {
         float val = 0;
@@ -1442 +1459 @@
         float sumBalancedRays = 0;
         float sumRaySplits = 0;
-        
-        int backId = 0;
-        int frontId = 0;
-        int frontAndBackId = 0;
 
         int frontPvs = 0;
@@ -1451 +1464 @@
 
         // probability that view point lies in child
-        float pOverall = 0;
-        float pFront = 0;
-        float pBack = 0;
+        float pOverall = 1;
+        float pFront = 0.5;
+        float pBack = 0.5;
 
         if (mSplitPlaneStrategy & PVS)
@@ -1459 +1472 @@
                 // create unique ids for pvs heuristics
                 GenerateUniqueIdsForPvs();
-
-                if (mPvsUseArea) // use front and back cell areas to approximate volume
-                {       
-                        // construct child geometry with regard to the candidate split plane
-                        BspNodeGeometry frontCell;
-                        BspNodeGeometry backCell;
-
-                        cell.SplitGeometry(frontCell, backCell, *this, candidatePlane);
-                
-                        pFront = frontCell.GetArea();
-                        pBack = backCell.GetArea();
-
-                        pOverall = area;
-                }
         }
                         
-        BoundedRayContainer::const_iterator rit, rit_end = rays.end();
-
-        for (rit = rays.begin(); rit != rays.end(); ++ rit)
-        {
-                Ray *ray = (*rit)->mRay;
-                const float minT = (*rit)->mMinT;
-                const float maxT = (*rit)->mMaxT;
+        bool useRand;;
+        int limit;
+
+        // choose test polyongs randomly if over threshold
+        if ((int)rays.size() > mMaxTests)
+        {
+                useRand = true;
+                limit = mMaxTests;
+        }
+        else
+        {
+                useRand = false;
+                limit = (int)rays.size();
+        }
+
+        for (int i = 0; i < limit; ++ i)
+        {
+                const int testIdx = useRand ? Random(limit) : i;
+        
+                BoundedRay *bRay = rays[testIdx];
+
+                Ray *ray = bRay->mRay;
+                const float minT = bRay->mMinT;
+                const float maxT = bRay->mMaxT;
 
                 Vector3 entP, extP;
@@ -1511 +1527 @@
                         AddObjToPvs(ray->sourceObject.mObject, cf, frontPvs, backPvs);
                         
-                        if (!mPvsUseArea) // use front and back cell areas to approximate volume
-                        {       
-                                float len = Distance(entP, extP);
-                                pOverall += len;
-
-                                // use length of rays to approximate volume
-                                switch (cf)
+                        float len = 1;
+                        if (0){
+                        if (mPvsUseLen)
+                                len = SqrDistance(entP, extP);
+                                                        
+                        // use length of rays to approximate volume
+                        if (Ray::BACK && Ray::COINCIDENT)
+                                pBack += len;
+                        if (Ray::FRONT && Ray::COINCIDENT)
+                                pFront += len;
+                        if (Ray::FRONT_BACK || Ray::BACK_FRONT)
+                        {
+                                if (mPvsUseLen)
                                 {
-                                        case Ray::COINCIDENT:
-                                                pBack += len;
-                                                pFront += len;                                          
-                                                break;
-                                        case Ray::BACK:
-                                                pBack += len;
-                                                break;
-                                        case Ray::FRONT:
-                                                pFront += len;
-                                                break;
-                                        case Ray::FRONT_BACK:
-                                                {
-                                                        // find intersection of ray segment with plane
-                                                        const Vector3 extp = ray->Extrap(maxT);
-                                                        const float t = candidatePlane.FindT(ray->GetLoc(), extp);
-                                        
-                                                        const float newT = t * maxT;
-                                                        float newLen = Distance(ray->Extrap(newT), extp);
-
-                                                        pFront += len - newLen;
-                                                        pBack += newLen;
-                                                }
-                                                break;
-                                        case Ray::BACK_FRONT:
-                                                {
-                                                        // find intersection of ray segment with plane
-                                                        const Vector3 extp = ray->Extrap(maxT);
-                                                        const float t = candidatePlane.FindT(ray->GetLoc(), extp);
-                                        
-                                                        const float newT = t * maxT;
-                                                        float newLen = Distance(ray->Extrap(newT), extp);
-
-                                                        pFront += len;
-                                                        pBack += len - newLen;
-                                                }
-                                                break;
-                                        default:
-                                                Debug << "Should not come here 2" << endl;
-                                                break;
+                                        const Vector3 extp = ray->Extrap(maxT);
+                                        const float t = candidatePlane.FindT(ray->GetLoc(), extp);
+                                
+                                        const float newT = t * maxT;
+                                        const float newLen = SqrDistance(ray->Extrap(newT), extp);
+
+                                        if (Ray::FRONT_BACK)
+                                        {
+                                                pFront += len - newLen;
+                                                pBack += newLen;
+                                        }
+                                        else
+                                        {
+                                                pBack += len - newLen;
+                                                pFront += newLen;
+                                        }
                                 }
-                        }
+                                else
+                                {
+                                        ++ pFront;
+                                        ++ pBack;
+                                }
+                        }}
                 }
         }
@@ -1572 +1576 @@
 
         float denom = pOverall * (float)pvs * 2.0f + Limits::Small;
-        if ((mSplitPlaneStrategy & PVS) && area && pvs)
+
+        if (mSplitPlaneStrategy & PVS)
         {
                 val += mPvsFactor * (frontPvs * pFront + (backPvs * pBack)) / denom;
 
                 // give penalty to unbalanced split
-                if (0)
+                if (1)
                 if (((pFront * 0.2 + Limits::Small) > pBack) || (pFront < (pBack * 0.2 + Limits::Small)))
                         val += 0.5;
         }
 
+        
 #ifdef _DEBUG
         Debug << "totalpvs: " << pvs << " ptotal: " << pOverall
@@ -1664 +1670 @@
                 (mSplitPlaneStrategy & PVS))
         {
-                val += SplitPlaneCost(candidatePlane, *data.mRays, data.mPvs, 
-                                                          data.mArea, *data.mGeometry);
+                val += SplitPlaneCost(candidatePlane, *data.mRays, data.mPvs);
         }
 
@@ -1736 +1741 @@
                 ++ mStat.maxRayContribNodes;
         
-        if (data.mGeometry->GetArea() <= mTermMinArea) 
-                ++ mStat.minAreaNodes;
+        //if (data.mGeometry->GetArea() <= mTermMinArea) 
+        //      ++ mStat.minAreaNodes;
 
 #ifdef _DEBUG
@@ -1950 +1955 @@
         }
 }
-
-bool BspTree::MergeViewCells(BspLeaf *front, BspLeaf *back) const
-{
-        BspViewCell *viewCell = 
-NULL;//todo             dynamic_cast<BspViewCell *>(ViewCell::Merge(*front->mViewCell, *back->mViewCell));
-        
-        if (!viewCell)
-                return false;
-
-        // change view cells of all leaves associated with the
-        // previous view cells
-
-        BspViewCell *fVc = front->mViewCell;
-        BspViewCell *bVc = back->mViewCell;
-
-        vector<BspLeaf *> fLeaves = fVc->mBspLeaves;
-        vector<BspLeaf *> bLeaves = bVc->mBspLeaves;
-
-        vector<BspLeaf *>::const_iterator it;
-        
-        for (it = fLeaves.begin(); it != fLeaves.end(); ++ it)
-        {
-                (*it)->SetViewCell(viewCell);
-                viewCell->mBspLeaves.push_back(*it);
-        }
-        for (it = bLeaves.begin(); it != bLeaves.end(); ++ it)
-        {
-                (*it)->SetViewCell(viewCell);
-                viewCell->mBspLeaves.push_back(*it);
-        }
-        
-        DEL_PTR(fVc);
-        DEL_PTR(bVc);
-
-        return true;
-}
-
-bool BspTree::ShouldMerge(BspLeaf *front, BspLeaf *back) const
-{
-        ViewCell *fvc = front->mViewCell;
-        ViewCell *bvc = back->mViewCell;
-
-        if ((fvc == mRootCell) || (bvc == mRootCell) || (fvc == bvc))
-                return false;
-
-        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;
-}
-
 
 BspTreeStatistics &BspTree::GetStat()
@@ -2457 +2402 @@
                                         if (frontPoly->Valid())
                                                 front.mPolys.push_back(frontPoly);
+                                        else
+                                                DEL_PTR(frontPoly);
+
                                         if (backPoly->Valid())
                                                 back.mPolys.push_back(backPoly);
+                                        else
+                                                DEL_PTR(backPoly);
                                 }
                                 
@@ -2510 +2460 @@
 
                                         planePoly->Split(plane, *frontPoly, *backPoly);
+                                        
+                                        // don't need anymore
                                         DEL_PTR(planePoly);
-
+                                        DEL_PTR(frontPoly);
+
+                                        // back polygon is belonging to geometry
                                         if (backPoly->Valid())
                                                 planePoly = backPoly;

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.h

@@ -364 +364 @@
                 /// rays piercing this node
                 BoundedRayContainer *mRays;
-                /// area of current node
-                float mArea;
-                BspNodeGeometry *mGeometry;
-
+                
                 /// pvs size
                 int mPvs;
@@ -385 +382 @@
                 mViewCell(NULL),
                 mRays(NULL),
-                mPvs(0),
-                mArea(0.0),
-                mGeometry(NULL)
+                mPvs(0)
                 {}
                 
@@ -395 +390 @@
                                                  ViewCell *viewCell,
                                                  BoundedRayContainer *rays,
-                                                 int pvs,
-                                                 float area,
-                                                 BspNodeGeometry *cell): 
+                                                 int pvs): 
                 mNode(node), 
                 mPolygons(polys), 
@@ -403 +396 @@
                 mViewCell(viewCell),
                 mRays(rays),
-                mPvs(pvs),
-                mArea(area),
-                mGeometry(cell)
+                mPvs(pvs)
                 {}
     };
@@ -412 +403 @@
 
         /** Default constructor creating an empty tree.
-                @param viewCell view cell corresponding to unbounded space
         */ 
-        BspTree(BspViewCell *viewCell);
-
+        BspTree();
+        
         ~BspTree();
 
+        
         const BspTreeStatistics &GetStatistics() const; 
   
@@ -506 +497 @@
         BspLeaf *GetRandomLeaf(const bool onlyUnmailed = false);
 
-        /** Returns true if merge criteria are reached.
-        */
-    bool ShouldMerge(BspLeaf *front, BspLeaf *back) const;
-
-        /** Merges view cells based on some criteria
-            E.g., empty view cells can pe purged, view cells which have 
-                a very similar PVS can be merged to one larger view cell.
-
-                @returns true if merge was successful.
-        */
-        bool MergeViewCells(BspLeaf *front, BspLeaf *back) const;
-
         /** Traverses tree and counts all view cells as well as their PVS size.
         */
         void EvaluateViewCellsStats(BspViewCellsStatistics &stat) const;
+
+        /** Returns view cell corresponding to unbounded space.
+        */
+        BspViewCell *GetRootCell() const;
 
         /** Parses the environment and stores the global BSP tree parameters
@@ -601 +584 @@
         float SplitPlaneCost(const Plane3 &candidatePlane, 
                                                  const BoundedRayContainer &rays,
-                                                 const int pvs,
-                                                 const float area,
-                                                 const BspNodeGeometry &cell) const;
+                                                 const int pvs) const;
 
         /** Filters next view cell down the tree and inserts it into the appropriate leaves
@@ -834 +815 @@
         /// number of candidates for split planes evaluated using the rays
         int mMaxRayCandidates;
-        
+        /// maximum tests for split plane evaluation with a single candidate
+        int mMaxTests;
+
         float mCtDivCi;
 
@@ -856 +839 @@
         float mBalancedViewCellsFactor;
 
-        //-- thresholds used for view cells merge
-        int mMinPvsDif;
-        int mMinPvs;
-        int mMaxPvs;
         /// if area or accumulated ray lenght should be used for PVS heuristics
-        bool mPvsUseArea;
+        bool mPvsUseLen;
 
 private:

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.cpp

@@ -13 +13 @@
 
 
-
 ViewCellsManager::ViewCellsManager():
 mRenderSimulator(NULL),
@@ -20 +19 @@
 mVisualizationSamples(0)
 {
-    mUnbounded = GenerateViewCell();
+        // post processing stuff
+        environment->GetIntValue("ViewCells.PostProcessing.minPvsDif", mMinPvsDif);
+        environment->GetIntValue("ViewCells.PostProcessing.minPvs", mMinPvs);
+        environment->GetIntValue("ViewCells.PostProcessing.maxPvs", mMaxPvs);
 }
 
@@ -29 +31 @@
 mVisualizationSamples(0)
 {
-        mUnbounded = GenerateViewCell();
+        // post processing stuff
+        environment->GetIntValue("ViewCells.PostProcessing.minPvsDif", mMinPvsDif);
+        environment->GetIntValue("ViewCells.PostProcessing.minPvs", mMinPvs);
+        environment->GetIntValue("ViewCells.PostProcessing.maxPvs", mMaxPvs);
 }
 
 ViewCellsManager::~ViewCellsManager()
 {
-        DEL_PTR(mUnbounded);
         DEL_PTR(mRenderSimulator);
 }
@@ -63 +67 @@
 }
 
-int ViewCellsManager::CastRays(const RayContainer &rays)
-{
-        int sampleContributions = 0;
+void ViewCellsManager::ComputeSampleContributions(const RayContainer &rays, 
+                                                                                                  const bool castRays,
+                                                                                                  int &sampleContributions,
+                                                                                                  int &contributingSamples)
+{
+        // view cells not yet constructed
+        if (!ViewCellsConstructed())
+                return;
 
         RayContainer::const_iterator it, it_end = rays.end();
 
     for (it = rays.begin(); it != it_end; ++ it)
-                sampleContributions += CastRay(*(*it));
-
-        return sampleContributions;
+        {
+                sampleContributions +=ComputeSampleContributions(*(*it), castRays);
+                contributingSamples += sampleContributions > 0;
+        }
 }
 
@@ -139 +149 @@
 }
 
-ViewCell *ViewCellsManager::Merge(ViewCell &front, ViewCell &back) const
+ViewCell *ViewCellsManager::MergeViewCells(ViewCell &front, ViewCell &back) const
 {
         ViewCell *vc = GenerateViewCell();
@@ -158 +168 @@
 SimulationStatistics ViewCellsManager::SimulateRendering() const
 {
+        if (!ViewCellsConstructed())
+                return SimulationStatistics();
+
         return mRenderSimulator->SimulateRendering();
 }
@@ -223 +236 @@
                                                                    AxisAlignedBox3 *sceneBbox)
 {
+        // if view cells were already constructed
         if (ViewCellsConstructed())
                 return 0;
 
+        Debug << "Constructing bsp view cells" << endl;
+
         int sampleContributions = 0;
         
@@ -235 +251 @@
                 sampleRays.push_back(new Ray(*rays[i]));
 
-        mBspTree->Construct(objects, sampleRays);
-        
+        if (mViewCells.empty()) // no view cells loaded
+                mBspTree->Construct(objects, sampleRays);
+        else
+                mBspTree->Construct(mViewCells);
+
         Debug << mBspTree->GetStatistics() << endl;
         CLEAR_CONTAINER(sampleRays);
@@ -243 +262 @@
 }
 
-int BspViewCellsManager::CastRay(Ray &ray)
-{
-        mBspTree->CastRay(ray);
+int BspViewCellsManager::ComputeSampleContributions(Ray &ray, const bool castRay)
+{
+        // view cells not yet constructed
+        if (!ViewCellsConstructed())
+                return 0;
+
+        int contributingSamples = 0;
+
+        if (castRay)
+                mBspTree->CastRay(ray);
         
         //if (mBspTree->bspIntersections.empty()) return 0;
 
-        Intersectable *term = 
+        Intersectable *tObject = 
                 !ray.intersections.empty() ? ray.intersections[0].mObject : NULL;
 
-        return AddSampleContributions(ray, ray.sourceObject.mObject, term);
+        Intersectable *sObject = ray.sourceObject.mObject;
+
+        if (sObject || tObject)
+        {
+                // object can be seen from the view cell => add to view cell pvs
+                for (int j = 0; j < (int)ray.bspIntersections.size(); ++ j)
+                {       
+                        BspLeaf *leaf = ray.bspIntersections[j].mLeaf;
+                
+                        // if ray not in unbounded space
+                        if (leaf->GetViewCell() != mBspTree->GetRootCell())
+                        {
+                                if (sObject)
+                                {
+                                        contributingSamples += 
+                                                leaf->GetViewCell()->GetPvs().AddSample(sObject);
+                                }
+
+                                if (tObject)
+                                {
+                                        contributingSamples += 
+                                                leaf->GetViewCell()->GetPvs().AddSample(tObject);
+                                }
+                        }
+                }
+        }
+
+        // rays passing through this viewcell
+        if (0)
+                for (int j = 1; j < ((int)ray.bspIntersections.size() - 1); ++ j) 
+                {
+                        BspLeaf *leaf = ray.bspIntersections[j].mLeaf;
+
+                        if (leaf->GetViewCell() != mBspTree->GetRootCell())
+                                leaf->GetViewCell()->
+                                        AddPassingRay(ray, contributingSamples ? 1 : 0);
+                }
+
+        return contributingSamples;
 }
 
@@ -258 +322 @@
                                                                          const RayContainer &rays)
 {
+        if (!ViewCellsConstructed())
+        {
+                Debug << "view cells not constructed" << endl;
+                return 0;
+        }
+
+
         //-- post processing of bsp view cells
     int vcSize = 0;
@@ -277 +348 @@
                         //exporter->ExportBspViewCellPartition(*mBspTree, 0);
                                 
-                        if (1)
+                        if (0)
                         {
                                 Material m;//= RandomMaterial();
@@ -323 +394 @@
                         BspLeaf *leaf = (*iit).mLeaf;
 
-                        if (mBspTree->ShouldMerge(leaf, previousLeaf))
+                        if (ShouldMerge(leaf, previousLeaf))
                         {                       
-                                mBspTree->MergeViewCells(leaf, previousLeaf);
+                                MergeBspLeafViewCells(leaf, previousLeaf);
 
                                 ++ merged;
@@ -347 +418 @@
 }
 
-int BspViewCellsManager::AddSampleContributions(const Ray &ray,
-                                                                                                Intersectable *sObject,
-                                                                                                Intersectable *tObject)
-{
-        int contributingSamples = 0;
-        
-        // rays passing through this viewcell
-        if (0)
-                for (int j = 1; j < ((int)ray.bspIntersections.size() - 1); ++ j) 
-                {
-                        BspLeaf *leaf = ray.bspIntersections[j].mLeaf;
-
-                        if (leaf->GetViewCell() != mUnbounded)
-                                leaf->GetViewCell()->
-                                        AddPassingRay(ray, contributingSamples ? 1 : 0);
-                }
-
-        if (!sObject && !tObject)
-                return 0;
-
-        // object can be seen from the view cell => add to view cell pvs
-        for (int j = 0; j < (int)ray.bspIntersections.size(); ++ j)
-        {       
-                BspLeaf *leaf = ray.bspIntersections[j].mLeaf;
-                
-                // if ray not in unbounded space
-                if (leaf->GetViewCell() != mUnbounded)
-                {
-                        if (sObject)
-                        {
-                                contributingSamples += 
-                                        leaf->GetViewCell()->GetPvs().AddSample(sObject);
-                        }
-
-                        if (tObject)
-                        {
-                                contributingSamples += 
-                                        leaf->GetViewCell()->GetPvs().AddSample(tObject);
-                        }
-                }
-        }
- 
-        return contributingSamples;
-}
-
 
 void BspViewCellsManager::Visualize(const ObjectContainer &objects,
                                                                         const RayContainer &sampleRays)
 {
+        if (!ViewCellsConstructed())
+                return;
+
         //-- recount pvs
         BspViewCellsStatistics vcStats;
@@ -473 +502 @@
                 }
 
-                if (1)
+                if (0)
                         exporter->ExportGeometry(objects);
 
@@ -681 +710 @@
 }
 
+
+bool BspViewCellsManager::MergeBspLeafViewCells(BspLeaf *front, BspLeaf *back) const
+{
+        BspViewCell *viewCell = 
+                dynamic_cast<BspViewCell *>(MergeViewCells(*front->GetViewCell(), *back->GetViewCell()));
+        
+        if (!viewCell)
+                return false;
+
+        // change view cells of all leaves associated with the
+        // previous view cells
+
+        BspViewCell *fVc = front->GetViewCell();
+        BspViewCell *bVc = back->GetViewCell();
+
+        vector<BspLeaf *> fLeaves = fVc->mBspLeaves;
+        vector<BspLeaf *> bLeaves = bVc->mBspLeaves;
+
+        vector<BspLeaf *>::const_iterator it;
+        
+        for (it = fLeaves.begin(); it != fLeaves.end(); ++ it)
+        {
+                (*it)->SetViewCell(viewCell);
+                viewCell->mBspLeaves.push_back(*it);
+        }
+        for (it = bLeaves.begin(); it != bLeaves.end(); ++ it)
+        {
+                (*it)->SetViewCell(viewCell);
+                viewCell->mBspLeaves.push_back(*it);
+        }
+        
+        DEL_PTR(fVc);
+        DEL_PTR(bVc);
+
+        return true;
+}
+
+bool BspViewCellsManager::ShouldMerge(BspLeaf *front, BspLeaf *back) const
+{
+        ViewCell *fvc = front->GetViewCell();
+        ViewCell *bvc = back->GetViewCell();
+
+        if ((fvc == mBspTree->GetRootCell()) || (bvc == mBspTree->GetRootCell()) || (fvc == bvc))
+                return false;
+
+        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;
+}
+
+
+
 /**********************************************************************/
 /*                   KdViewCellsManager implementation               */
@@ -698 +789 @@
                                                                   AxisAlignedBox3 *sceneBbox)
 {
+        // if view cells already constructed
         if (ViewCellsConstructed())
                 return 0;
+
+        Debug << "Constructing bsp view cells" << endl;
         
         mKdTree->Construct();
@@ -720 +814 @@
                                                                    const RayContainer &sampleRays)
 {
+        if (!ViewCellsConstructed())
+                return;
+
         const int pvsOut = min((int)objects.size(), 10);
 
@@ -801 +898 @@
 }
 
-int KdViewCellsManager::CastRay(const Ray &ray)
-{
-        if (ray.kdLeaves.empty()) 
+int KdViewCellsManager::ComputeSampleContributions(Ray &ray, const bool castRay)
+{
+        // view cells not yet constructed
+        if (!ViewCellsConstructed())
                 return 0;
 
-        Intersectable *terminator =
+        if (castRay)
+                mKdTree->CastRay(ray);
+
+        if (ray.kdLeaves.empty())
+                return 0;
+
+        Intersectable *tObject =
                 !ray.intersections.empty() ? ray.intersections[0].mObject : NULL;
 
-        return AddSampleContributions(ray, ray.sourceObject.mObject, terminator);
-}
-
-int KdViewCellsManager::AddSampleContributions(const Ray &ray,
-                                                                                           Intersectable *sObject,
-                                                                                           Intersectable *tObject)
-{
+        Intersectable *sObject =
+                ray.sourceObject.mObject;
+
         int contributingSamples = 0;
         
@@ -843 +943 @@
                         contributingSamples += tObject->mKdPvs.AddSample(node);
         }
-                
+
         return contributingSamples;
 }
+
 
 KdNode *KdViewCellsManager::GetNodeForPvs(KdLeaf *leaf)
@@ -874 +975 @@
                                                                          AxisAlignedBox3 *sceneBbox)
 {
+        // if view cells already constructed
         if (ViewCellsConstructed())
                 return 0;
@@ -886 +988 @@
 }
 
-int VspKdViewCellsManager::CastRay(const Ray &rays)
-{
+int VspKdViewCellsManager::ComputeSampleContributions(Ray &ray, const bool castRay)
+{
+        // view cells not yet constructed
+        if (!ViewCellsConstructed())
+                return 0;
+
+        //if (castRay) // TODO
+
         int sampleContributions = 0;
+
 /*
     for (int i = 0; i < (int)rays.size(); ++ i)
@@ -910 +1019 @@
                                                                            const RayContainer &rays)
 {
+        if (!ViewCellsConstructed())
+                return 0;
+
         return 0;
 }
@@ -916 +1028 @@
                                                                           const RayContainer &sampleRays)
 {
+        if (!ViewCellsConstructed())
+                return;
+
         if (1)
         {
@@ -1006 +1121 @@
         return VSP_KD;
 }
-
-int VspKdViewCellsManager::AddSampleContributions(const Ray &ray,
-                                                                                                Intersectable *sObject,
-                                                                                                Intersectable *tObject)
-{
-        int contributingSamples = 0;
-        /*
-        // rays passing through this viewcell
-        if (0)
-                for (int j = 1; j < ((int)ray.bspIntersections.size() - 1); ++ j) 
-                {
-                        BspLeaf *leaf = ray.bspIntersections[j].mLeaf;
-
-                        if (leaf->GetViewCell() != mUnbounded)
-                                leaf->GetViewCell()->
-                                        AddPassingRay(ray, contributingSamples ? 1 : 0);
-                }
-
-        if (!sObject && !tObject)
-                return 0;
-        
-        // object can be seen from the view cell => add to view cell pvs
-        for (j=0; j < (int)ray.bspIntersections.size(); ++ j)
-        {       
-                BspLeaf *leaf = ray.bspIntersections[j].mLeaf;
-                
-                // if ray not in unbounded space
-                if (leaf->GetViewCell() != mUnbounded)
-                {
-                        if (sObject)
-                        {
-                                contributingSamples += 
-                                        leaf->GetViewCell()->GetPvs().AddSample(sObject);
-                        }
-
-                        if (tObject)
-                        {
-                                contributingSamples += 
-                                        leaf->GetViewCell()->GetPvs().AddSample(tObject);
-                        }
-                }
-        }
- */
-        return contributingSamples;
-}

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.h

@@ -45 +45 @@
                                                   AxisAlignedBox3 *sceneBbox = NULL) = 0;
 
-        /** Casts bundle of rays to the view cells and stores contributions in PVS.
-        */
-        int CastRays(const RayContainer &rays);
-
-        /** Casts ray to the view cells and stores contributions in PVS.
-        */
-        virtual int CastRay(const Ray &ray) = 0;
+        /** Computes sample contributions of the rays to the view cells PVS.
+        
+                @param rays bundle of rays used to find intersections with view cells and 
+                adding the contribution
+                @param castRays true if ray should be cast to gain the information, false if rays
+                already hold the view cells intersection information and need not be recast.
+                @param sampleContributions returns the number of sample contributions
+                @param contributingSamples returns the number of contributingSamples
+        */
+        void  ComputeSampleContributions(const RayContainer &rays, 
+                                                                         const bool castRays,
+                                                                         int &sampleContributions,
+                                                                         int &contributingSamples);
+
+
+        /** Computes sample contribution of a simgle ray to the view cells PVS.
+                @param ray finds intersections with view cells and holds the contribution
+                @param castRay true if ray should be cast to gain the information, false if ray
+                is already holding the information and need not be recast.
+
+                @returns number of sample contributions
+        */
+        virtual int ComputeSampleContributions(Ray &ray, const bool castRay = true) = 0;
 
         /** Post processes view cells givemŽa number of rays.
@@ -91 +107 @@
                 @returns new view cell based on the merging.
         */
-        ViewCell *Merge(ViewCell &front, ViewCell &back) const;
+        ViewCell *MergeViewCells(ViewCell &front, ViewCell &back) const;
         
         /** Generates view cell of type specified by this manager
@@ -136 +152 @@
         virtual bool ViewCellsConstructed() const = 0;
         
+        
+
 protected:
-        /** Adds sample constributions to the view cell PVS.
-                @returns number of sample contributions
-        */
-        virtual int AddSampleContributions(const Ray &ray,
-                                                                           Intersectable *sObject,
-                                                                           Intersectable *tObject) = 0;
+        
+        
 
         /** Initialises the render time simulator.
@@ -163 +177 @@
         int mPostProcessSamples;
         int mVisualizationSamples;
+
+        //-- thresholds used for view cells merge
+        int mMinPvsDif;
+        int mMinPvs;
+        int mMaxPvs;
 };
+
+
 
 /**
@@ -179 +200 @@
                                   AxisAlignedBox3 *sceneBbox);
 
-        int CastRay(const Ray &rays);
+        int ComputeSampleContributions(Ray &ray, const bool castRay = false);
 
         int PostProcess(const ObjectContainer &objects, 
@@ -189 +210 @@
         int GetType() const;
         
-        /** Generates view cell of type specified by this manager
-        */
         ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;
 
@@ -197 +216 @@
 protected:
 
-        int     AddSampleContributions(const Ray &ray, Intersectable *sObject, Intersectable *tObject);
+        /** Merges view cells front and back leaf view cell.
+        */
+        bool MergeBspLeafViewCells(BspLeaf *front, BspLeaf *back) const;
+
+        /** Returns true if front and back leaf should be merged.
+        */
+        bool ShouldMerge(BspLeaf *front, BspLeaf *back) const;
 
         /// the BSP tree.
@@ -247 +272 @@
          KdNode *GetNodeForPvs(KdLeaf *leaf);
 
-         int AddSampleContributions(const Ray &ray, Intersectable *sObject, Intersectable *tObject);
-
-        /// the BSP tree.
-        KdTree *mKdTree;
-
-        /// depth of the KD tree nodes with represent the view cells
-        int mKdPvsDepth;
+         int ComputeSampleContributions(Ray &ray, const bool castRay = true);
+
+         /// the BSP tree.
+         KdTree *mKdTree;
+
+         /// depth of the KD tree nodes with represent the view cells
+         int mKdPvsDepth;
 };
 
@@ -271 +296 @@
                                   AxisAlignedBox3 *sceneBbox);
 
-        int CastRay(const Ray &rays);
+        int ComputeSampleContributions(Ray &ray, const bool castRay = true);
 
         int PostProcess(const ObjectContainer &objects, 
@@ -285 +310 @@
 
 protected:
-
-        int     AddSampleContributions(const Ray &ray, Intersectable *sObject, Intersectable *tObject);
 
         /// the BSP tree.

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp

@@ -222 +222 @@
 mRoot(NULL), 
 mStoreLeavesWithRays(false),
-mPvsUseArea(true)
+mPvsUseLen(true)
 {
         Randomize(); // initialise random generator for heuristics
@@ -485 +485 @@
 
         VspBspTraversalData tData(mRoot, polys, 0, mRootCell, rays, 
-                                                   ComputePvsSize(*rays), cell->GetArea(), cell);
+                                                   ComputePvsSize(*rays));
 
         tStack.push(tData);
@@ -515 +515 @@
                 (((int)data.mRays->size() <= mTermMinRays) ||
                  (data.mPvs <= mTermMinPvs) ||
-                 (data.mArea <= mTermMinArea) ||
                  (data.mDepth >= mTermMaxDepth) ||
                  (data.GetAvgRayContribution() < mTermMaxRayContribution));
@@ -548 +547 @@
                 DEL_PTR(tData.mPolygons);
                 DEL_PTR(tData.mRays);
-                DEL_PTR(tData.mGeometry);
+                //DEL_PTR(tData.mGeometry);
                 
                 return leaf;
@@ -557 +556 @@
         
         VspBspTraversalData tFrontData(NULL, new PolygonContainer(), tData.mDepth + 1, mRootCell, 
-                                                                new RayInfoContainer(), 0, 0, new VspBspNodeGeometry());
+                                                                new RayInfoContainer(), 0);
         VspBspTraversalData tBackData(NULL, new PolygonContainer(), tData.mDepth + 1, mRootCell, 
-                                                           new RayInfoContainer(), 0, 0, new VspBspNodeGeometry());
+                                                           new RayInfoContainer(), 0);
 
         // create new interior node and two leaf nodes
@@ -583 +582 @@
         DEL_PTR(tData.mPolygons);
         DEL_PTR(tData.mRays);
-        DEL_PTR(tData.mGeometry);               
+        //DEL_PTR(tData.mGeometry);             
 
         return interior;
@@ -616 +615 @@
         frontData.mPvs = ComputePvsSize(*frontData.mRays);
         backData.mPvs = ComputePvsSize(*backData.mRays);
-
-        // split geometry and compute area
-        if (1)
-        {
-                tData.mGeometry->SplitGeometry(*frontData.mGeometry, 
-                                                                           *backData.mGeometry, 
-                                                                           *this, 
-                                                                           interior->mPlane);
-        
-                
-                frontData.mArea = frontData.mGeometry->GetArea();
-                backData.mArea = backData.mGeometry->GetArea();
-        }
 
         // compute accumulated ray length
@@ -1006 +992 @@
 
         if (mSplitPlaneStrategy & PVS)
-        {
                 // create unique ids for pvs heuristics
                 GenerateUniqueIdsForPvs();
-
-                if (mPvsUseArea) // use front and back cell areas to approximate volume
-                {       
-                        // construct child geometry with regard to the candidate split plane
-                        VspBspNodeGeometry frontCell;
-                        VspBspNodeGeometry backCell;
-
-                        data.mGeometry->SplitGeometry(frontCell, backCell, *this, candidatePlane);
-                
-                        pFront = frontCell.GetArea();
-                        pBack = backCell.GetArea();
-
-                        pOverall = data.mArea;
-                }
-        }
+        
                         
         RayInfoContainer::const_iterator rit, rit_end = data.mRays->end();
@@ -1055 +1026 @@
                         AddObjToPvs(ray->mOriginObject, cf, frontPvs, backPvs);
                         
-                        if (!mPvsUseArea) // use front and back cell areas to approximate volume
-                        {       
-                                const float len = (*rit).SegmentLength();
-                                pOverall += len;
-
-                                // use length of rays to approximate volume
-                                if (cf == 1)
-                                        pFront += len;
-                                if (cf == -1)
-                                        pBack += len;
-                                if (cf == 0)
+                        float len = 1;
+
+                        if (mPvsUseLen) // use front and back cell areas to approximate volume
+                                len = (*rit).SqrSegmentLength();
+                        
+                        pOverall += len;
+
+                        // use length of rays to approximate volume
+                        if (cf == 1)
+                                pFront += len;
+                        if (cf == -1)
+                                pBack += len;
+                        if (cf == 0)
+                        {
+                                if (mPvsUseLen)
                                 {
                                         float newLen = len * 
@@ -1071 +1046 @@
                                                 ((*rit).GetMaxT() - (*rit).GetMinT());
 
+                                
                                         if (candidatePlane.Side((*rit).ExtrapOrigin()) <= 0)
                                         {
@@ -1081 +1057 @@
                                                 pBack += len - newLen;
                                         }
-                                }                               
+                                }
+                                else
+                                {
+                                        ++ pFront;
+                                        ++ pBack;
+                                }
                         }
                 }
@@ -1094 +1075 @@
                 val += mBalancedRaysFactor * fabs(sumBalancedRays) /  raysSize;
 
-        float denom = pOverall * (float)data.mPvs * 2.0f + Limits::Small;
-        if ((mSplitPlaneStrategy & PVS) && data.mArea && data.mPvs)
+        const float denom = pOverall * (float)data.mPvs * 2.0f + Limits::Small;
+
+        if (mSplitPlaneStrategy & PVS)
         {
                 val += mPvsFactor * (frontPvs * pFront + (backPvs * pBack)) / denom;
 
                 // give penalty to unbalanced split
-                if (1)
+                if (0)
                 if (((pFront * 0.2 + Limits::Small) > pBack) || (pFront < (pBack * 0.2 + Limits::Small)))
                         val += 0.5;
@@ -1217 +1199 @@
                 ++ mStat.maxRayContribNodes;
         
-        if (data.mGeometry->GetArea() <= mTermMinArea) 
-                ++ mStat.minAreaNodes;
 
 #ifdef _DEBUG

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.h

@@ -349 +349 @@
                 /// rays piercing this node
                 RayInfoContainer *mRays;
-                /// area of current node
-                float mArea;
-                /// geometry of current node induced by split planes
-                VspBspNodeGeometry *mGeometry;
 
                 /// pvs size
@@ -371 +367 @@
                 mViewCell(NULL),
                 mRays(NULL),
-                mPvs(0),
-                mArea(0.0),
-                mGeometry(NULL)
+                mPvs(0)
                 {}
                 
@@ -381 +375 @@
                                                  ViewCell *viewCell,
                                                  RayInfoContainer *rays,
-                                                 int pvs,
-                                                 float area,
-                                                 VspBspNodeGeometry *cell): 
+                                                 int pvs): 
                 mNode(node), 
                 mPolygons(polys), 
@@ -389 +381 @@
                 mViewCell(viewCell),
                 mRays(rays),
-                mPvs(pvs),
-                mArea(area),
-                mGeometry(cell)
+                mPvs(pvs)
                 {}
     };
@@ -762 +752 @@
 
         /// if area or accumulated ray lenght should be used for PVS heuristics
-        bool mPvsUseArea;
+        bool mPvsUseLen;
 
 private:

trunk/VUT/GtpVisibilityPreprocessor/src/VssRay.h

@@ -77 +77 @@
 
         if (!ray.intersections.empty())
-          {
+        {
                 mTermination = ray.Extrap(ray.intersections[0].mT);
                 mTerminationObject = ray.intersections[0].mObject;
-          }
+        }
         else
-          {
+        {
                 mTermination = ray.Extrap(1e6);//TODO: should be Limits::Infinity
                 mTerminationObject = NULL;
-          }
+        }
 
         Precompute();