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

Timestamp:

12/14/05 19:38:39 (19 years ago)

Author:

bittner

Message:

changed the viewcellsmanager interface to use vssrays - some functionality like the bsp merging is now restricted

File:

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

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.cpp

@@ -67 +67 @@
 }
 
-void ViewCellsManager::ComputeSampleContributions(const RayContainer &rays, 
-                                                                                                  int &sampleContributions,
-                                                                                                  int &contributingSamples,
-                                                                                                  const bool castRays)
-{
-        // view cells not yet constructed
-        if (!ViewCellsConstructed())
-                return;
-
-        RayContainer::const_iterator it, it_end = rays.end();
-
-        sampleContributions = 0;
-        contributingSamples = 0;
-
-    for (it = rays.begin(); it != it_end; ++ it)
-        {
-                sampleContributions += ComputeSampleContributions(*(*it), castRays);
-                contributingSamples += sampleContributions > 0;
-        }
+void
+ViewCellsManager::ComputeSampleContributions(const VssRayContainer &rays
+                                                                                         )
+{
+  // view cells not yet constructed
+  if (!ViewCellsConstructed())
+        return;
+  
+  VssRayContainer::const_iterator it, it_end = rays.end();
+  for (it = rays.begin(); it != it_end; ++ it) {
+        ComputeSampleContributions(*(*it));
+  }
 }
 
@@ -277 +270 @@
 }
 
-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 *tObject = 
-                !ray.intersections.empty() ? ray.intersections[0].mObject : NULL;
-
-        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 outside of view 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;
-}
-
-int BspViewCellsManager::PostProcess(const ObjectContainer &objects, 
-                                                                         const RayContainer &rays)
-{
-        if (!ViewCellsConstructed())
+void
+ViewCellsManager::ComputeSampleContributions(VssRay &ray)
+{
+
+  ViewCellContainer viewcells;
+  
+  CastLineSegment(ray.mOrigin,
+                                  ray.mTermination,
+                                  viewcells
+                                  );
+  
+  ViewCellContainer::const_iterator it = viewcells.begin();
+  for (; it != viewcells.end(); ++it) {         
+        ViewCell *viewcell = *it;
+        
+        // if ray not outside of view space
+        float contribution;
+        bool added = 
+          viewcell->GetPvs().AddSample(ray.mTerminationObject,
+                                                                   contribution
+                                                                   );
+        if (added)
+          ray.mPvsContribution++;
+        
+        ray.mRelativePvsContribution += contribution;
+  }
+  
+}
+
+int
+BspViewCellsManager::CastLineSegment(const Vector3 &origin,
+                                                                         const Vector3 &termination,
+                                                                         ViewCellContainer &viewcells
+                                                                         )
+{
+  return mBspTree->CastLineSegment(origin, termination, viewcells);
+}
+
+int
+BspViewCellsManager::PostProcess(const ObjectContainer &objects, 
+                                                                 const VssRayContainer &rays)
+{
+  if (!ViewCellsConstructed())
         {
                 Debug << "view cells not constructed" << endl;
@@ -391 +366 @@
         long startTime = GetTime();
 
+        // $$JB we do not have connectivity information from the ray in the moment
+        // perhaps we could recast the rays or rember the cells traversed inside the
+        // vssray (which would on other hand create some overhead)
         //-- merge or subdivide view cells
         int merged = 0;
+#if 0
 
         RayContainer::const_iterator rit, rit_end = rays.end();
@@ -427 +406 @@
                 }
         }
-
+#endif
         //-- stats and visualizations
         cout << "finished" << endl;
@@ -443 +422 @@
 
 void BspViewCellsManager::Visualize(const ObjectContainer &objects,
-                                                                        const RayContainer &sampleRays)
-{
-        if (!ViewCellsConstructed())
-                return;
-
-        //-- recount pvs
-        ViewCellsStatistics vcStats;
-        mBspTree->EvaluateViewCellsStats(vcStats);
-
-        if (1) // export view cells
-        {
-                cout << "exporting view cells after merge ... ";
-                Exporter *exporter = Exporter::GetExporter("merged_view_cells.x3d");
-
-                if (exporter)
-                {
-                        exporter->ExportBspViewCellPartition(*mBspTree, vcStats.maxPvs);
-                        //exporter->ExportBspViewCellPartition(*mBspTree, 0);
-                        delete exporter;
-                }
-
-                cout << "finished" << endl;
+                                                                        const VssRayContainer &sampleRays)
+{
+  if (!ViewCellsConstructed())
+        return;
+  
+  //-- recount pvs
+  ViewCellsStatistics vcStats;
+  mBspTree->EvaluateViewCellsStats(vcStats);
+  
+  if (1) // export view cells
+        {
+          cout << "exporting view cells after merge ... ";
+          Exporter *exporter = Exporter::GetExporter("merged_view_cells.x3d");
+          
+          if (exporter)
+                {
+                  exporter->ExportBspViewCellPartition(*mBspTree, vcStats.maxPvs);
+                  //exporter->ExportBspViewCellPartition(*mBspTree, 0);
+                  delete exporter;
+                }
+          
+          cout << "finished" << endl;
         }       
-
-        //-- visualization of the BSP splits
-        bool exportSplits = false;
-                environment->GetBoolValue("BspTree.Visualization.exportSplits", exportSplits);
-        
-        if (exportSplits)
-        {
-                cout << "exporting splits ... ";
-                ExportSplits(objects, sampleRays);
-                cout << "finished" << endl;
-        }
-
-        ExportBspPvs(objects, sampleRays);
+  
+  //-- visualization of the BSP splits
+  bool exportSplits = false;
+  environment->GetBoolValue("BspTree.Visualization.exportSplits", exportSplits);
+  
+  if (exportSplits)
+        {
+          cout << "exporting splits ... ";
+          ExportSplits(objects, sampleRays);
+          cout << "finished" << endl;
+        }
+  
+  ExportBspPvs(objects, sampleRays);
 }
 
@@ -488 +467 @@
 
 void BspViewCellsManager::ExportSplits(const ObjectContainer &objects,
-                                                                           const RayContainer &sampleRays)
+                                                                           const VssRayContainer &sampleRays)
 {
         Exporter *exporter = Exporter::GetExporter("bsp_splits.x3d");
@@ -510 +489 @@
                 if (0)
                 {
-                        RayContainer outRays;
-                
-                        int raysSize = min((int)sampleRays.size(), mVisualizationSamples);
-
-                        for (int i = 0; i < raysSize; ++ i)
-                        {
-                                // only rays piercing geometry
-                                if (!sampleRays[i]->intersections.empty())
-                                        outRays.push_back(sampleRays[i]);
-                        }
-                        
-                        // export rays 
-                        exporter->ExportRays(outRays, 1000, RgbColor(1, 1, 0));
-                }
-
+                  VssRayContainer outRays;
+                  
+                  int raysSize = min((int)sampleRays.size(), mVisualizationSamples);
+                  
+                  for (int i = 0; i < raysSize; ++ i)
+                        {
+                          // only rays piercing geometry
+                          outRays.push_back(sampleRays[i]);
+                        }
+                  
+                  // export rays 
+                  exporter->ExportRays(outRays, RgbColor(1, 1, 0));
+                }
+                
                 if (0)
-                        exporter->ExportGeometry(objects);
-
+                  exporter->ExportGeometry(objects);
+                
                 delete exporter;
         }
@@ -533 +511 @@
 
 void BspViewCellsManager::ExportBspPvs(const ObjectContainer &objects,
-                                                                           const RayContainer &sampleRays)
-{
-        const int leafOut = 10;
-        
-        ViewCell::NewMail();
-
-        //-- some rays for output
-        const int raysOut = min((int)sampleRays.size(), mVisualizationSamples);
-        Debug << "visualization using " << raysOut << " samples" << endl;
-        
-
-        if (1)
-        {
-                //-- some random view cells and rays for output
-                vector<BspLeaf *> bspLeaves;
-
-                for (int i = 0; i < leafOut; ++ i)
-                        bspLeaves.push_back(mBspTree->GetRandomLeaf()); 
-                
-                for (int i = 0; i < bspLeaves.size(); ++ i)
-                {
-                        BspLeaf *leaf = bspLeaves[i];
-
-                        RayContainer vcRays;
-                
-                        cout << "creating output for view cell " << i << " ... ";
-
-                        // check whether we can add the current ray to the output rays
-                        for (int k = 0; k < raysOut; ++ k) 
-                        {
-                                Ray *ray = sampleRays[k];
-
-                                for     (int j = 0; j < (int)ray->bspIntersections.size(); ++ j)
+                                                                           const VssRayContainer &sampleRays)
+{
+  const int leafOut = 10;
+  
+  ViewCell::NewMail();
+  
+  //-- some rays for output
+  const int raysOut = min((int)sampleRays.size(), mVisualizationSamples);
+  Debug << "visualization using " << raysOut << " samples" << endl;
+
+  //$$ JB
+#if 0
+
+  if (1)
+        {
+          //-- some random view cells and rays for output
+          vector<BspLeaf *> bspLeaves;
+          
+          for (int i = 0; i < leafOut; ++ i)
+                bspLeaves.push_back(mBspTree->GetRandomLeaf()); 
+
+          
+          for (int i = 0; i < bspLeaves.size(); ++ i)
+                {
+                  BspLeaf *leaf = bspLeaves[i];
+                  
+                  RayContainer vcRays;
+                  
+                  cout << "creating output for view cell " << i << " ... ";
+                  
+                  // check whether we can add the current ray to the output rays
+                  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()) 
+                                  BspLeaf *leaf2 = ray->bspIntersections[j].mLeaf;
+                                  
+                                  if (leaf->GetViewCell() == leaf2->GetViewCell()) 
                                         {
-                                                vcRays.push_back(ray);
+                                          vcRays.push_back(ray);
                                         }
                                 }
                         }
-
-            Intersectable::NewMail();
-
-                        BspViewCell *vc = dynamic_cast<BspViewCell *>(leaf->GetViewCell());
-
-                        //bspLeaves[j]->Mail();
-                        char s[64]; sprintf(s, "bsp-pvs%04d.x3d", i);
-
-                        Exporter *exporter = Exporter::GetExporter(s);
-                        exporter->SetFilled();
-
-                        exporter->SetWireframe();
-                        //exporter->SetFilled();
-
-                        Material m;//= RandomMaterial();
-                        m.mDiffuseColor = RgbColor(1, 1, 0);
-                        exporter->SetForcedMaterial(m);
-
-                        if (vc->GetMesh())
-                                exporter->ExportViewCell(vc);
-                        else
-                        {
-                                PolygonContainer vcGeom;
-                                // export view cell geometry
-                                mBspTree->ConstructGeometry(vc, vcGeom);
-                                exporter->ExportPolygons(vcGeom);
+                  
+                  Intersectable::NewMail();
+                  
+                  BspViewCell *vc = dynamic_cast<BspViewCell *>(leaf->GetViewCell());
+                  
+                  //bspLeaves[j]->Mail();
+                  char s[64]; sprintf(s, "bsp-pvs%04d.x3d", i);
+                  
+                  Exporter *exporter = Exporter::GetExporter(s);
+                  exporter->SetFilled();
+
+                  exporter->SetWireframe();
+                  //exporter->SetFilled();
+                  
+                  Material m;//= RandomMaterial();
+                  m.mDiffuseColor = RgbColor(1, 1, 0);
+                  exporter->SetForcedMaterial(m);
+                  
+                  if (vc->GetMesh())
+                        exporter->ExportViewCell(vc);
+                  else
+                        {
+                          PolygonContainer vcGeom;
+                          // export view cell geometry
+                          mBspTree->ConstructGeometry(vc, vcGeom);
+                          exporter->ExportPolygons(vcGeom);
                                 CLEAR_CONTAINER(vcGeom);
                         }
-
-                        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));  
-                        
-                        m.mDiffuseColor = RgbColor(1, 0, 0);
-                        exporter->SetForcedMaterial(m);
-
-                        // exporter->SetWireframe();
-                        exporter->SetFilled();
-
-                        ViewCellPvsMap::iterator it, it_end = vc->GetPvs().mEntries.end();
-                        // output PVS of view cell
-                        for (it = vc->GetPvs().mEntries.begin(); it !=  it_end; ++ it) 
-                        {
-                                Intersectable *intersect = (*it).first;
-                                if (!intersect->Mailed())
+                  
+                  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));        
+                  
+                  m.mDiffuseColor = RgbColor(1, 0, 0);
+                  exporter->SetForcedMaterial(m);
+                  
+                  // exporter->SetWireframe();
+                  exporter->SetFilled();
+                  
+                  ViewCellPvsMap::iterator it, it_end = vc->GetPvs().mEntries.end();
+                  // output PVS of view cell
+                  for (it = vc->GetPvs().mEntries.begin(); it !=  it_end; ++ it) 
+                        {
+                          Intersectable *intersect = (*it).first;
+                          if (!intersect->Mailed())
                                 {
-                                        exporter->ExportIntersectable(intersect);
-                                        intersect->Mail();
+                                  exporter->ExportIntersectable(intersect);
+                                  intersect->Mail();
                                 }                       
                         }
-
-                        DEL_PTR(exporter);
-                        cout << "finished" << endl;
-                }
-        }
-        else
-        {
-                ViewCellContainer viewCells;
-                RayContainer vcRays;
-
-                mBspTree->CollectViewCells(viewCells);
-                stable_sort(viewCells.begin(), viewCells.end(), vc_gt);
-
-                int limit = min(leafOut, (int)viewCells.size()); 
-                
-                for (int i = 0; i < limit; ++ i)
-                {
-                        cout << "creating output for view cell " << i << " ... ";
+                  
+                  DEL_PTR(exporter);
+                  cout << "finished" << endl;
+                }
+        }
+  else
+        {
+          ViewCellContainer viewCells;
+          RayContainer vcRays;
+          
+          mBspTree->CollectViewCells(viewCells);
+          stable_sort(viewCells.begin(), viewCells.end(), vc_gt);
+          
+          int limit = min(leafOut, (int)viewCells.size()); 
+          
+          for (int i = 0; i < limit; ++ i)
+                {
+                  cout << "creating output for view cell " << i << " ... ";
                         
             Intersectable::NewMail();
@@ -721 +702 @@
                 }
         }
+#endif
 }
 
@@ -822 +804 @@
 
 int KdViewCellsManager::PostProcess(const ObjectContainer &objects, 
-                                                                        const RayContainer &rays)
+                                                                        const VssRayContainer &rays)
 {
         return 0;
@@ -828 +810 @@
 
 void KdViewCellsManager::Visualize(const ObjectContainer &objects,
-                                                                   const RayContainer &sampleRays)
+                                                                   const VssRayContainer &sampleRays)
 {
         if (!ViewCellsConstructed())
@@ -837 +819 @@
         int limit = min(mVisualizationSamples, (int)sampleRays.size());
 
-        RayContainer *rays = new RayContainer[pvsOut];
+        VssRayContainer *rays = new VssRayContainer[pvsOut];
 
         for  (int i = 0; i < limit; ++ i)
         {
-                Ray *ray = sampleRays[i];
-
-                if (!ray->intersections.empty()) 
-                {
-                        // check whether we can add this to the rays
-                        for (int j = 0; j < pvsOut; j++) 
-                        {
-                                if (objects[j] == ray->intersections[0].mObject) 
-                                {
-                                        rays[j].push_back(ray);
-                                }
-                        }
-                }
-        }
+          VssRay *ray = sampleRays[i];
+          
+          // check whether we can add this to the rays
+          for (int j = 0; j < pvsOut; j++) 
+                {
+                  if (objects[j] == ray->mTerminationObject)
+                        {
+                          rays[j].push_back(ray);
+                        }
+                }
+        }
+        
 
         bool exportRays = false;
         if (exportRays) {
-                Exporter *exporter = NULL;
+          Exporter *exporter = NULL;
                 exporter = Exporter::GetExporter("sample-rays.x3d");
                 exporter->SetWireframe();
@@ -864 +844 @@
                 
                 for (i=0; i < pvsOut; i++) 
-                        exporter->ExportRays(rays[i], 1000, RgbColor(1, 0, 0));
+                        exporter->ExportRays(rays[i], RgbColor(1, 0, 0));
                 exporter->SetFilled();
                 
@@ -893 +873 @@
                 }
 
-                exporter->ExportRays(rays[k], 1000, RgbColor(0, 1, 0));
+                exporter->ExportRays(rays[k],  RgbColor(0, 1, 0));
                 exporter->SetFilled();
                  
@@ -914 +894 @@
 }
 
-int KdViewCellsManager::ComputeSampleContributions(Ray &ray, const bool castRay)
-{
-        // view cells not yet constructed
-        if (!ViewCellsConstructed())
-                return 0;
-
-        if (castRay)
-                mKdTree->CastRay(ray);
-
-        if (ray.kdLeaves.empty())
-                return 0;
-
-        Intersectable *tObject =
-                !ray.intersections.empty() ? ray.intersections[0].mObject : NULL;
-
-        Intersectable *sObject =
-                ray.sourceObject.mObject;
-
-        int contributingSamples = 0;
-        
-        int objects = 0;
-
-        if (sObject)
-                objects++;
-        if (tObject)
-                objects++;
-
-        for (int j = 1; j < ((int)ray.kdLeaves.size() - 1); ++ j) 
-        {
-                ray.kdLeaves[j]->AddPassingRay2(ray, objects,
-                                                                                (int)ray.kdLeaves.size());
-        }
-
-        if (!objects)
-                return 0;
-        
-        for (int j=0; j < ray.kdLeaves.size(); j++) 
-        {
-                KdNode *node = GetNodeForPvs(ray.kdLeaves[j]);
-
-                if (sObject)
-                        contributingSamples += sObject->mKdPvs.AddSample(node);
-                if (tObject)
-                        contributingSamples += tObject->mKdPvs.AddSample(node);
-        }
-
-        return contributingSamples;
-}
 
 
@@ -976 +908 @@
 void KdViewCellsManager::PrintStatistics(ostream &s) const
 {
+}
+
+
+int
+KdViewCellsManager::CastLineSegment(const Vector3 &origin,
+                                                                        const Vector3 &termination,
+                                                                        ViewCellContainer &viewcells
+                                                                        )
+{
+
+  return 0;
 }
 
@@ -1031 +974 @@
 }
 
-int VspKdViewCellsManager::ComputeSampleContributions(Ray &ray, const bool castRay)
-{
-        // view cells not yet constructed
+
+ViewCell *VspKdViewCellsManager::GenerateViewCell(Mesh *mesh) const
+{
+        return new VspKdViewCell(mesh);
+}
+
+int VspKdViewCellsManager::PostProcess(const ObjectContainer &objects, 
+                                                                           const VssRayContainer &rays)
+{
         if (!ViewCellsConstructed())
                 return 0;
 
-//      if (castRay)
-//              mVspKdTree->CastRay(ray);
-
-        int sampleContributions = 0;
-
-        return sampleContributions;
-}
-
-ViewCell *VspKdViewCellsManager::GenerateViewCell(Mesh *mesh) const
-{
-        return new VspKdViewCell(mesh);
-}
-
-int VspKdViewCellsManager::PostProcess(const ObjectContainer &objects, 
-                                                                           const RayContainer &rays)
-{
-        if (!ViewCellsConstructed())
-                return 0;
-
         return mVspKdTree->MergeLeaves();
 }
 
 void VspKdViewCellsManager::Visualize(const ObjectContainer &objects,
-                                                                          const RayContainer &sampleRays)
+                                                                          const VssRayContainer &sampleRays)
 {
         if (!ViewCellsConstructed())
@@ -1079 +1009 @@
 
                 if (exportRays) 
-                {
+                  {
                         int raysSize = 2000;
                         float prob = raysSize / (float)sampleRays.size();
@@ -1085 +1015 @@
                         exporter->SetWireframe();
                         
-                        RayContainer rays;
+                        VssRayContainer rays;
                 
                         for (int i = 0; i < sampleRays.size(); ++ i)
@@ -1093 +1023 @@
                         }
 
-                        exporter->ExportRays(rays, 1000, RgbColor(1, 0, 0));
+                        exporter->ExportRays(rays, RgbColor(1, 0, 0));
                 }
 
@@ -1165 +1095 @@
                 exporter->SetWireframe();
                         
-                RayContainer rays;
+                VssRayContainer rays;
                 
                 for (int i = 0; i < sampleRays.size(); ++ i)
                 {
-                        if (RandomValue(0,1) < prob)
-                                rays.push_back(sampleRays[i]);
-                }
-                exporter->ExportRays(rays, 1000, RgbColor(1, 0, 0));
+                  if (RandomValue(0,1) < prob)
+                        rays.push_back(sampleRays[i]);
+                }
+                exporter->ExportRays(rays, RgbColor(1, 0, 0));
         }
 
@@ -1191 +1121 @@
 }
 
+
+int
+VspKdViewCellsManager::CastLineSegment(const Vector3 &origin,
+                                                                           const Vector3 &termination,
+                                                                           ViewCellContainer &viewcells
+                                                                           )
+{
+  
+  return 0;
+}
 
 /**********************************************************************/
@@ -1252 +1192 @@
 }
 
-int VspBspViewCellsManager::ComputeSampleContributions(Ray &ray, const bool castRay)
-{
-        // view cells not yet constructed
-        if (!ViewCellsConstructed())
-                return 0;
-
-        int contributingSamples = 0;
-
-        if (castRay)
-                mVspBspTree->CastRay(ray);
-
-        Intersectable *tObject = 
-                !ray.intersections.empty() ? ray.intersections[0].mObject : NULL;
-
-        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() != mVspBspTree->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() != mVspBspTree->GetRootCell())
-                                leaf->GetViewCell()->
-                                        AddPassingRay(ray, contributingSamples ? 1 : 0);
-                }
-
-        return contributingSamples;
-}
 
 int VspBspViewCellsManager::PostProcess(const ObjectContainer &objects, 
-                                                                                const RayContainer &rays)
+                                                                                const VssRayContainer &rays)
 {
         if (!ViewCellsConstructed())
@@ -1356 +1242 @@
 
 
+        // $$JB we do not have connectivity information from the ray in the moment
+        // perhaps we could recast the rays or rember the cells traversed inside the
+        // vssray (which would on other hand create some overhead)
         //-- merge or subdivide view cells
         int merged = 0;
+#if 0
 
         RayContainer::const_iterator rit, rit_end = rays.end();
@@ -1366 +1256 @@
         for (int i = 0; i < limit; ++ i)
         {  
-                Ray *ray = rays[i];
-
-                // traverse leaves stored in the rays and compare and merge consecutive
-                // leaves (i.e., the neighbors in the tree)
-                if (ray->bspIntersections.size() < 2)
-                        continue;
-
-                iit = ray->bspIntersections.begin();
+          VssRay *ray = rays[i];
+          
+          // traverse leaves stored in the rays and compare and merge consecutive
+          // leaves (i.e., the neighbors in the tree)
+          if (ray->bspIntersections.size() < 2)
+                continue;
+          
+          iit = ray->bspIntersections.begin();
 
                 BspLeaf *previousLeaf = (*iit).mLeaf;
@@ -1392 +1282 @@
                 }
         }
-
+#endif
         //-- stats and visualizations
         cout << "finished" << endl;
@@ -1409 +1299 @@
 
 void VspBspViewCellsManager::Visualize(const ObjectContainer &objects,
-                                                                           const RayContainer &sampleRays)
+                                                                           const VssRayContainer &sampleRays)
 {
         if (!ViewCellsConstructed())
@@ -1448 +1338 @@
 
 void VspBspViewCellsManager::ExportSplits(const ObjectContainer &objects,
-                                                                                  const RayContainer &sampleRays)
+                                                                                  const VssRayContainer &sampleRays)
 {
         Exporter *exporter = Exporter::GetExporter("bsp_splits.x3d");
@@ -1471 +1361 @@
                 if (0)
                 {
-                        RayContainer outRays;
+                  VssRayContainer outRays;
                 
                         int raysSize = min((int)sampleRays.size(), mVisualizationSamples);
@@ -1478 +1368 @@
                         {
                                 // only rays piercing geometry
-                                if (!sampleRays[i]->intersections.empty())
-                                        outRays.push_back(sampleRays[i]);
+                          outRays.push_back(sampleRays[i]);
                         }
                         
                         // export rays 
-                        exporter->ExportRays(outRays, 1000, RgbColor(1, 1, 0));
+                        exporter->ExportRays(outRays, RgbColor(1, 1, 0));
                 }
 
@@ -1494 +1383 @@
 
 void VspBspViewCellsManager::ExportBspPvs(const ObjectContainer &objects,
-                                                                                  const RayContainer &sampleRays)
+                                                                                  const VssRayContainer &sampleRays)
 {
         const int leafOut = 10;
@@ -1514 +1403 @@
                 for (int i = 0; i < (int)vspBspLeaves.size(); ++ i)
                 {
-                        RayContainer vcRays;
-                        cout << "creating output for view cell " << i << " ... ";
-                        
+                  VssRayContainer vcRays;
+                  cout << "creating output for view cell " << i << " ... ";
+
+                  //$$JB
+#if 0
                         // check whether we can add the current ray to the output rays
                         for (int k = 0; k < raysOut; ++ k) 
                         {
-                                Ray *ray = sampleRays[k];
+                          VssRay *ray = sampleRays[k];
 
                                 for     (int j = 0; j < (int)ray->bspIntersections.size(); ++ j)
@@ -1532 +1423 @@
                                 }
                         }
-                        
+#endif
 
                         Intersectable::NewMail();
@@ -1570 +1461 @@
 
                         // export rays piercing this view cell
-                        exporter->ExportRays(vcRays, 1000, RgbColor(1, 0, 0));
+                        exporter->ExportRays(vcRays, RgbColor(1, 0, 0));
                         exporter->ExportRays(vspBspLeaves[i]->mVssRays, RgbColor(1, 1, 1));
                         
@@ -1621 +1512 @@
                 {
                         cout << "creating output for view cell " << i << " ... ";
-                        RayContainer vcRays;
+                        VssRayContainer vcRays;
             Intersectable::NewMail();
                         BspViewCell *vc = dynamic_cast<BspViewCell *>(viewCells[i]);
 
                         cout << "creating output for view cell " << i << " ... ";
+                        //$$ JB
+#if 0
                         // check whether we can add the current ray to the output rays
                         for (int k = 0; k < raysOut; ++ k) 
                         {
-                                Ray *ray = sampleRays[k];
+                          Ray *ray = sampleRays[k];
 
                                 for     (int j = 0; j < (int)ray->bspIntersections.size(); ++ j)
@@ -1641 +1534 @@
                                 }
                         }
-
+#endif
                         //bspLeaves[j]->Mail();
                         char s[64]; sprintf(s, "bsp-pvs%04d.x3d", i);
@@ -1670 +1563 @@
                         
                         // export rays piercing this view cell
-                        exporter->ExportRays(vcRays, 1000, RgbColor(0, 1, 0));
+                        exporter->ExportRays(vcRays, RgbColor(0, 1, 0));
         
                         m.mDiffuseColor = RgbColor(1, 0, 0);
@@ -1771 +1664 @@
 }
 
+
+int
+VspBspViewCellsManager::CastLineSegment(const Vector3 &origin,
+                                                                                const Vector3 &termination,
+                                                                                ViewCellContainer &viewcells
+                                                                                )
+{
+  return mVspBspTree->CastLineSegment(origin, termination, viewcells);
+}