Changeset 1418 for GTP/trunk/Lib/Vis/Preprocessing/src

Timestamp:

09/19/06 22:33:29 (18 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/Lib/Vis/Preprocessing/src

Files:

• Environment.cpp (modified) (2 diffs)
• Exporter.cpp (modified) (9 diffs)
• Exporter.h (modified) (1 diff)
• HierarchyManager.cpp (modified) (7 diffs)
• HierarchyManager.h (modified) (4 diffs)
• Mesh.cpp (modified) (3 diffs)
• Mesh.h (modified) (2 diffs)
• Plane3.h (modified) (2 diffs)
• Polygon3.cpp (modified) (2 diffs)
• Preprocessor.cpp (modified) (3 diffs)
• Preprocessor.h (modified) (1 diff)
• ViewCellBsp.cpp (modified) (1 diff)
• ViewCellsManager.cpp (modified) (30 diffs)
• VspBspTree.cpp (modified) (1 diff)
• VspTree.cpp (modified) (9 diffs)
• VssPreprocessor.cpp (modified) (2 diffs)
• X3dParser.cpp (modified) (2 diffs)
• main.cpp (modified) (3 diffs)

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

@@ -1274 +1274 @@
                                         "view_cells_evaluation_stats_prefix=",
                                         "viewCells");
+
         RegisterOption("ViewCells.Evaluation.histogram",
                                         optBool,
@@ -1490 +1491 @@
 
         
-        /************************************************************************************/
-        /*                         Render simulation related options                        */
-        /************************************************************************************/
+        /****************************************************************************/
+        /*                     Render simulation related options                    */
+        /****************************************************************************/
 
 

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

@@ -106 +106 @@
 bool Exporter::ExportBvHierarchy(const BvHierarchy &bvHierarchy, 
                                                                  const int maxPvs,
-                                                                 const AxisAlignedBox3 *box)
+                                                                 const AxisAlignedBox3 *box,
+                                                                 const bool exportBoundingBoxes)
 {
         vector<BvhLeaf *> leaves;
@@ -122 +123 @@
         {
                 BvhLeaf *leaf = *it;
-                if (leaf->mObjects.empty())
+
+                if (leaf->mObjects.empty() || 
+                        (box && !Overlap(*box, leaf->GetBoundingBox())))
                         continue;
 
-                if (box && !Overlap(*box, leaf->GetBoundingBox()))
-                        continue;
-
-                SetWireframe();
-                SetForcedMaterial(white);
-                ExportBox(leaf->GetBoundingBox());
-                SetFilled();
-
-                if (maxPvs) // color code pvs
+                if (exportBoundingBoxes)
+                {
+                        SetWireframe();
+                        SetForcedMaterial(white);
+                        ExportBox(leaf->GetBoundingBox());
+                }
+
+        if (maxPvs) // color code pvs
                 {
                         mForcedMaterial.mDiffuseColor.b = 1.0f;
@@ -146 +148 @@
                 }
 
-                if (1) 
-                {
-                        SetFilled();
-                        ExportGeometry(leaf->mObjects, true);
-                }
-        }
+                SetFilled();
+                ExportGeometry(leaf->mObjects, true);
+        }
+
+        SetFilled();
 
         return true;
@@ -176 +177 @@
                 {
                         const Triangle3 triangle = dynamic_cast<TriangleIntersectable *>(object)->GetItem();
-
-                        VertexContainer vertices;
-                        vertices.push_back(triangle.mVertices[0]);
-                        vertices.push_back(triangle.mVertices[1]);
-                        vertices.push_back(triangle.mVertices[2]);
-
-                        Polygon3 poly(vertices);
+                        Polygon3 poly(triangle);
                         ExportPolygon(&poly);
                         break;
                 }
+        case Intersectable::BVH_INTERSECTABLE:
+                {
+                        BvhNode *node = dynamic_cast<BvhIntersectable *>(object)->GetItem();
+                        if (node->IsLeaf())
+                                ExportGeometry(dynamic_cast<BvhLeaf *>(node)->mObjects, true);
+                        break;
+                }
         default:
                 cerr << "Sorry the export for object type " << Intersectable::GetTypeName(object) << " is not available yet" << endl;
@@ -191 +193 @@
         }
 }
+
 
 void Exporter::ExportMeshInstance(MeshInstance *object)
@@ -234 +237 @@
                 for (oit = objects.begin(); oit != oit_end; ++ oit)
                 {
-                        if (bbox && Overlap(*bbox, (*oit)->GetBox()))
+                        if (!bbox || Overlap(*bbox, (*oit)->GetBox()))
                         {
                                 if (0) SetForcedMaterial(RandomMaterial());
@@ -240 +243 @@
                         }
                 }
-
                 return;
         }
-
         
-        ///////////////////////////////////////////
+
+        ///////////////////////
         //-- all objects exported as one mesh
-        //-- hack: currently works only for triangles
+        //-- warning: currently works only for triangles
 
         PolygonContainer polys;
@@ -255 +257 @@
                 Intersectable *obj = *oit;
 
-                if (bbox && !Overlap(*bbox, (*oit)->GetBox()))
+                if (bbox && !Overlap(*bbox, obj->GetBox()))
+                {
+                        //cout << *bbox << " " << obj->GetBox() << endl;
                         continue;
+                }
 
                 switch (obj->Type())
@@ -266 +271 @@
                 break;
                         }
+                case Intersectable::MESH_INSTANCE:
+                        {
+                                MeshInstance *mi = dynamic_cast<MeshInstance *>(obj);
+                                ExportMesh(mi->GetMesh());
+                                //polys.push_back(new Polygon3(ti->GetItem()));
+                break;
+                        }
                 default:
                         cout << "merging of object type " << obj->Type() << " not implemented yet" << endl;

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

@@ -154 +154 @@
           const BvHierarchy &bvHierarchy, 
           const int maxPvs, 
-          const AxisAlignedBox3 *box = NULL);
+          const AxisAlignedBox3 *box = NULL,
+          const bool exportBoundingBoxes = true);
 
   virtual void ExportMeshInstance(MeshInstance *mi);

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

@@ -281 +281 @@
         RunConstruction(sampleRays, objects, forcedViewSpace);
         
-        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
-
+        cout << "\nfinished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+
+        cout << "here5 " << GetViewSpaceBox() << endl;
+        cout << "here6 " << GetObjectSpaceBox() << endl;
         mHierarchyStats.Stop();
         mVspTree->mVspStats.Stop();
-        FinishObjectSpaceSubdivision();
+        FinishObjectSpaceSubdivision(objects);
 
         mObjectSpaceSubdivisionType = mSavedObjectSpaceSubdivisionType;
@@ -762 +764 @@
 void HierarchyManager::ExportObjectSpaceHierarchy(Exporter *exporter,
                                                                                                   const ObjectContainer &objects,
-                                                                                                  const AxisAlignedBox3 *bbox) const
+                                                                                                  const AxisAlignedBox3 *bbox,
+                                                                                                  const bool exportBounds) const
 {
         switch (mObjectSpaceSubdivisionType)
@@ -773 +776 @@
         case BV_BASED_OBJ_SUBDIV:
                 {
-                        ExportBvHierarchy(exporter, objects, bbox);
+                        exporter->ExportBvHierarchy(*mBvHierarchy, 0, bbox, exportBounds);
                         break;
                 }
@@ -779 +782 @@
                 break;
         }
-}
-
-
-void HierarchyManager::ExportBvHierarchy(Exporter *exporter, 
-                                                                                 const ObjectContainer &objects,
-                                                                                 const AxisAlignedBox3 *bbox) const
-{
-        exporter->SetWireframe();
-        exporter->ExportBvHierarchy(*mBvHierarchy, 0, bbox);
 }
 
@@ -801 +795 @@
 
 
+Intersectable *HierarchyManager::GetIntersectable(const VssRay &ray, 
+                                                                                                  const bool isTermination) const
+{
+
+        Intersectable *obj;
+        Vector3 pt;
+        KdNode *node;
+
+        ray.GetSampleData(isTermination, pt, &obj, &node);
+        
+        if (!obj) return NULL;
+
+        switch (mObjectSpaceSubdivisionType)
+        {
+        case HierarchyManager::KD_BASED_OBJ_SUBDIV:
+                {
+                        KdLeaf *leaf = mOspTree->GetLeaf(pt, node);
+                        return mOspTree->GetOrCreateKdIntersectable(leaf);
+                }
+        case HierarchyManager::BV_BASED_OBJ_SUBDIV:
+                {
+                        BvhLeaf *leaf = mBvHierarchy->GetLeaf(obj);
+                        return mBvHierarchy->GetOrCreateBvhIntersectable(leaf);
+                }
+        default:
+                return obj;
+        }
+}
+
+
 void HierarchyStatistics::Print(ostream &app) const
 {
@@ -823 +847 @@
 
 
-void HierarchyManager::FinishObjectSpaceSubdivision() const
+static void RemoveRayRefs(const ObjectContainer &objects)
+{
+        ObjectContainer::const_iterator oit, oit_end = objects.end();
+        for (oit = objects.begin(); oit != oit_end; ++ oit)
+        {
+                (*oit)->mVssRays.clear();
+        }
+}
+
+
+void HierarchyManager::FinishObjectSpaceSubdivision(const ObjectContainer &objects) const
 {
         switch (mObjectSpaceSubdivisionType)
@@ -835 +869 @@
                 {
                         mBvHierarchy->mBvhStats.Stop();
+                        RemoveRayRefs(objects);
                         break;
                 }

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

@@ -206 +206 @@
                 Exporter *exporter, 
                 const ObjectContainer &objects,
-                const AxisAlignedBox3 *bbox) const;
-
+                const AxisAlignedBox3 *bbox,
+                const bool exportBounds = true) const;
+
+
+        Intersectable *GetIntersectable(
+                const VssRay &ray, 
+                const bool isTermination) const;
 
 protected:
@@ -254 +259 @@
         void ExportOspTree(Exporter *exporter, const ObjectContainer &objects) const;
 
-        void ExportBvHierarchy(
-                Exporter *exporter, 
-                const ObjectContainer &objects, 
-                const AxisAlignedBox3 *box) const;
-
-        void PrepareBvHierarchy(
-                const VssRayContainer &sampleRays,
-                const ObjectContainer &objects);
-
-        void PrepareOspTree(
-                const VssRayContainer &sampleRays,
-                const ObjectContainer &objects);
-
         void ParseEnvironment();
 
@@ -272 +264 @@
         bool StartViewSpaceSubdivision() const;
 
+        void PrepareBvHierarchy(
+                const VssRayContainer &sampleRays,
+                const ObjectContainer &objects);
+
+        void PrepareOspTree(
+                const VssRayContainer &sampleRays,
+                const ObjectContainer &objects);
+
         void PrepareViewSpaceSubdivision(
                 const VssRayContainer &sampleRays,
@@ -281 +281 @@
     void ResetQueue();
 
-        void FinishObjectSpaceSubdivision() const;
+        void FinishObjectSpaceSubdivision(const ObjectContainer &objects) const;
 
         int GetObjectSpaceSubdivisionDepth() const;

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

@@ -476 +476 @@
 
 Plane3
-Mesh::GetFacePlane(const int faceIndex)
+Mesh::GetFacePlane(const int faceIndex) const
 {
   Face *face = mFaces[faceIndex];
@@ -521 +521 @@
 
 
+Vector3 Mesh::GetNormal(const int idx) const
+{
+        return GetFacePlane(idx).mNormal;
+}
+
+
 void
 Mesh::AddTriangle(const Triangle3 &triangle)
@@ -728 +734 @@
 Vector3 MeshInstance::GetNormal(const int idx) const
 {
-        return mMesh->GetFacePlane(idx).mNormal;
+        return mMesh->GetNormal(idx);
 }
 

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

@@ -187 +187 @@
                                           );
   
-  Plane3 GetFacePlane(const int faceIndex);
+  Plane3 GetFacePlane(const int faceIndex) const;
 
   AxisAlignedBox3 GetFaceBox(const int faceIndex);
@@ -207 +207 @@
   }
 
+
+  Vector3 GetNormal(const int idx) const;
+
   virtual ostream &Describe(ostream &s) {
         return s<<"Mesh #vertices="<<(int)mVertices.size()<<" #faces="<<(int)mFaces.size();

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

@@ -77 +77 @@
         AxisAlignedPlane(){}
         AxisAlignedPlane(const int axis, const float position):
-          mAxis(axis), mPosition(position)
+          mAxis(axis), mPosition(position), mOrientation(false)
           {
           }
         Plane3 GetPlane() const
         {
-                Vector3 normal(0,0,0); normal[mAxis] = 1;
+                Vector3 normal(0,0,0); normal[mAxis] = mOrientation ? 1.0f : -1.0f;
                 Vector3 point(0,0,0); point[mAxis] = mPosition;
 
@@ -92 +92 @@
         /// the absolute position of the split axis
         float mPosition;
+        /// the plane orientation
+        bool mOrientation;
+
+        friend ostream &operator<<(ostream &s, const AxisAlignedPlane &p) 
+        {
+                s << "a: " << p.mAxis << " p: " << p.mPosition;
+                return s;
+        }
 };
-
-
 }
-
 #endif

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

@@ -66 +66 @@
         mVertices.push_back(tri.mVertices[1]);
         mVertices.push_back(tri.mVertices[2]);
+
+        //cout << "poly n: " << GetNormal() << " t normal: " << tri.GetNormal() << endl;
 }
 
@@ -539 +541 @@
         while (i < k)
         {
-                triangles.push_back(Triangle3(mVertices[i], mVertices[j], mVertices[k]));
+                if (0) // matt: I don't know why i made it like this because the normals are wrong!! 
+                        triangles.push_back(Triangle3(mVertices[i], mVertices[j], mVertices[k]));
+                else
+                        triangles.push_back(Triangle3(mVertices[k], mVertices[j], mVertices[i]));
 
                 if ((count ++) % 2)

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

@@ -788 +788 @@
 
 
-bool Preprocessor::InitRayCast(const string externKdTree)
-{
-        bool loadKdTree, exportKdTree;
-
+bool Preprocessor::InitRayCast(const string externKdTree, const string internkdtree)
+{
+        bool loadKdTree;
         Environment::GetSingleton()->GetBoolValue("Preprocessor.loadKdTree", loadKdTree);
-        Environment::GetSingleton()->GetBoolValue("Preprocessor.exportKdTree", exportKdTree);
-
-        char kdtreename[100];
-        Environment::GetSingleton()->GetStringValue("Preprocessor.kdTreeFilename", kdtreename);
-
         
         if (!loadKdTree)
-        {       //////
+        {       
                 //-- build new kd tree from scene geometry
                 BuildKdTree();
@@ -808 +802 @@
         {
                 const long startTime = GetTime();
-                cout << "loading kd tree file " << kdtreename << " ... ";
-
-                if (!LoadKdTree(kdtreename))
+                cout << "loading kd tree file " << internkdtree << " ... ";
+
+                if (!LoadKdTree(internkdtree))
                 {
-                        cout << "error loading kd tree with filename " << kdtreename << endl;
-                        return false;
+                        cout << "error loading kd tree with filename " << internkdtree << ", rebuilding it instead ..." << endl;
+
+                        BuildKdTree();
+                        KdTreeStatistics(cout);
                 }
 
@@ -827 +823 @@
                                 delete exporter;
                         }
-                }
-        }
-
-        if (exportKdTree)
-        {
-                const long startTime = GetTime();
-                cout << "exporting kd tree ... ";
-                if (!ExportKdTree(kdtreename))
-                {
-                        cout << " error exporting kd tree with filename " << kdtreename << endl;
-                }
-                else
-                {
-                        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
                 }
         }

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

@@ -168 +168 @@
   GlRendererBuffer *GetRenderer() { return renderer;}
 
-  bool InitRayCast(const string externKdTree);
+  bool InitRayCast(const string externKdTree, const string internKdTree);
 
   int CastRay(

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

@@ -130 +130 @@
 {
         DEL_PTR(mPvs);
+
+        VssRayContainer::const_iterator vit, vit_end = mVssRays.end();
+        for (vit = mVssRays.begin(); vit != vit_end; ++ vit)
+        {
+                VssRay *ray = *vit;
+                ray->Unref();
+
+                if (!ray->IsActive())
+                        delete ray;
+        }
 }
 

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

@@ -181 +181 @@
 
 
-
-        Debug << "************ View Cells options ***************" << endl;
+        Debug << "************ View Cells Manager options ***************" << endl;
         Debug << "color code: " << mColorCode << endl;
 
@@ -211 +210 @@
         Debug << "export bounding boxes: " << mExportBboxesForPvs << endl;
         Debug << "export pvs for view cells: " << mExportPvs << endl;
-        
         Debug << endl;
 }
@@ -511 +509 @@
 
 
-AxisAlignedPlane * ViewCellsManager::GetClipPlane()
+AxisAlignedPlane *ViewCellsManager::GetClipPlane()
 {
         return mUseClipPlaneForViz ? &mClipPlaneForViz : NULL;
@@ -1696 +1694 @@
         int axis = 0;
         float pos;
+        bool orientation;
+        Vector3 absPos;
 
         Environment::GetSingleton()->GetFloatValue("ViewCells.Visualization.clipPlanePos", pos);
-        Vector3 absPos = mViewSpaceBox.Min() +  mViewSpaceBox.Size() * pos;
-        
         Environment::GetSingleton()->GetIntValue("ViewCells.Visualization.clipPlaneAxis", axis);
 
+        if (axis < 0) 
+        {
+                axis = -axis;
+                orientation = false;
+                absPos = mViewSpaceBox.Max() -  mViewSpaceBox.Size() * pos;
+        }
+        else
+        {
+                orientation = true;
+                absPos = mViewSpaceBox.Min() +  mViewSpaceBox.Size() * pos;
+        }
+
         mClipPlaneForViz = AxisAlignedPlane(axis, absPos[axis]);
+        mClipPlaneForViz.mOrientation = orientation;
 }
 
@@ -2658 +2669 @@
 
         
-        /////////////////////////////////////////
+        ////////////////////////
         //-- visualization and statistics
 
@@ -2729 +2740 @@
         if (1) FinalizeViewCells(true);
 
-        // write view cells to disc
-        if (mExportViewCells)
+        // write view cells to disc (this moved to preprocessor)
+        if (0 && mExportViewCells)
         {
                 char filename[100];
@@ -2843 +2854 @@
 
         // sort view cells in order to find the largest view cells
-        if (0)
-                stable_sort(mViewCells.begin(), mViewCells.end(), ViewCell::SmallerPvs);
+        if (0) stable_sort(mViewCells.begin(), mViewCells.end(), ViewCell::SmallerPvs);
 
         int limit = min(leafOut, (int)mViewCells.size());
@@ -3840 +3850 @@
         }
 
-
         // view cells already finished before post processing step 
         // (i.e. because they were loaded)
@@ -3885 +3894 @@
         if (0) FinalizeViewCells(false);
                 
-        //////////////////////////////////////
+        //////////////////
         //-- merge the individual view cells
         MergeViewCells(postProcessRays, objects);
@@ -3893 +3902 @@
         if (0) RefineViewCells(postProcessRays, objects);
 
-        ///////////////////////////////////////////
+        //////////////////
         //-- render simulation after merge + refine
 
@@ -3904 +3913 @@
         
 
-        ///////////////////
+        ////////////
         //-- compression
 
@@ -3927 +3936 @@
         // compute final meshes and volume / area
         if (1) FinalizeViewCells(true);
-
+cout << "here09*******************" << endl;
         // write view cells to disc
-        if (mExportViewCells)
-        {
+        if (0 && mExportViewCells)
+        {cout << "here77*******************" << endl;
                 char filename[100];
                 Environment::GetSingleton()->GetStringValue("ViewCells.filename", filename);
@@ -4832 +4841 @@
         }
 
-
-        // take this step only if 
-        // view cells already constructed before post processing step 
-        // (e.g., because they were loaded)
+        // if view cells were already constructed before post processing step 
+        // (e.g., because they were loaded), we are finished
         if (mViewCellsFinished)
         {
@@ -4881 +4888 @@
         mViewCellsTree->SetRoot(root);
 
-        ////////////////////////////////////
+
+        //////////////////////////
         //-- update pvs in the whole hierarchy
         ObjectPvs pvs;
@@ -4887 +4895 @@
 
 
-        ///////////////////////////////////////////
+        //////////////////////
         //-- render simulation after merge + refine
 
@@ -4896 +4904 @@
         cout << ss << endl;
         
-        ///////////////////////
+        ///////////////
         //-- compression
 
@@ -4910 +4918 @@
         }
 
-        /////////////////////////////////////
+        ///////////////
         //-- compute final meshes and volume / area
         if (1) FinalizeViewCells(true);
 
-
-        // write out view cells
-        if (mExportViewCells)
-        {
+        // write out view cells (this moved to preprocessor)
+        if (0 && mExportViewCells)
+        {
+                cout << "here5" << endl;
                 char filename[100];
                 Environment::GetSingleton()->GetStringValue("ViewCells.filename", filename);
@@ -5005 +5013 @@
 {
         ViewCellContainer leaves;
-
         mViewCellsTree->CollectLeaves(vc, leaves);
         ViewCellContainer::const_iterator it, it_end = leaves.end();
 
         Plane3 plane;
-
         if (clipPlane)
+        {
+                // arbitrary plane definition
                 plane = clipPlane->GetPlane();
+        }
 
         for (it = leaves.begin(); it != it_end; ++ it)
@@ -5022 +5031 @@
                         mHierarchyManager->GetVspTree()->GetBoundingBox(vspVc->mLeaf);
                 
-                if (!Overlap(*sceneBox, box))
+                if (sceneBox && !Overlap(*sceneBox, box))
                         continue;
 
@@ -5033 +5042 @@
                         else if (box.Side(plane) == 0)
                         {
+                                // intersection
                                 AxisAlignedBox3 fbox, bbox;
-                                bbox.Split(clipPlane->mAxis, clipPlane->mPosition, fbox, bbox);
-
+                                box.Split(clipPlane->mAxis, clipPlane->mPosition, fbox, bbox);
                                 exporter->ExportBox(bbox);
                         }
@@ -5083 +5092 @@
                         cout << "exporting final view cells (after initial construction + post process) ... ";
 
-                        // matt: hack
+                        // matt: hack for clamping scene
                         AxisAlignedBox3 bbox = mHierarchyManager->GetViewSpaceBox();
                         bbox.Scale(Vector3(0.5, 1, 0.5));
-
-                        if (mExportGeometry)
+                        
+                        exporter->SetWireframe(); 
+                        exporter->ExportBox(bbox);
+                        exporter->SetFilled(); 
+
+                                
+                        if (0 && mExportGeometry)
                         {
                                 exporter->ExportGeometry(objects, true, &bbox);
@@ -5097 +5111 @@
                                 exporter->ExportRays(visRays, RgbColor(0, 1, 0));
                         }
-
+                
+                        mHierarchyManager->ExportObjectSpaceHierarchy(exporter, objects, &bbox, false);
                         ExportViewCellsForViz(exporter, &bbox, GetClipPlane());
-                
                         delete exporter;
                         cout << "finished in " << TimeDiff(starttime, GetTime()) * 1e-3f << " secs" << endl;
@@ -5145 +5159 @@
         Debug << "\nOutput view cells: " << endl;
 
-        const bool sortViewCells = true;
-
-        if (sortViewCells)
-        {
-                //stable_sort(mViewCells.begin(), mViewCells.end(), ViewCell::SmallerPvs);
+        const bool sortedViewCells = false;
+
+        if (sortedViewCells)
+        {
                 // sort view cells to visualize the view cells with highest render cost
                 stable_sort(mViewCells.begin(), mViewCells.end(), ViewCell::LargerRenderCost);
@@ -5157 +5170 @@
         int raysOut = 0;
 
-        ///////////////////////////
+        ///////////////
         //-- some rays for output
         
@@ -5163 +5176 @@
         {
                 cout << "creating output for view cell " << i << " ... ";
-
-                ViewCell *vc;
-        
-                if (sortViewCells) // largest view cell pvs first
-                        vc = mViewCells[i];
-                else // random view cell
-                        vc = mViewCells[(int)RandomValue(0, (float)mViewCells.size() - 1)];
-
+                
+                // largest view cell pvs first of random view cell
+                ViewCell *vc = sortedViewCells ? 
+                        mViewCells[i] : mViewCells[(int)RandomValue(0, (float)mViewCells.size() - 1)];
+                
                 ObjectPvs pvs;
                 mViewCellsTree->GetPvs(vc, pvs);
@@ -5179 +5189 @@
                 Debug << i << ": pvs size=" << (int)mViewCellsTree->GetPvsSize(vc) << endl;
 
+                ////////////
                 //-- export the sample rays
+
                 if (1 || mExportRays)
                 {
@@ -5199 +5211 @@
                                 {
                                         VspLeaf *vcLeaf = dynamic_cast<VspViewCell *>(*vit)->mLeaf;
-                                
                                         VssRayContainer::const_iterator rit, rit_end = vcLeaf->mVssRays.end();
 
@@ -5212 +5223 @@
                                 for (rit = collectRays.begin(); rit != rit_end; ++ rit)
                                 {
-                                        float p = RandomValue(0.0f, (float)collectRays.size());
+                                        const float p = RandomValue(0.0f, (float)collectRays.size());
                         
                                         if (p < raysOut)
                                                 vcRays.push_back(*rit);
                                 }
-
+                                
                                 //-- export rays piercing this view cell
                                 exporter->ExportRays(vcRays, RgbColor(1, 1, 1));
+
+                                //-- export objects seen from the rays
+                                Intersectable::NewMail();
+                VssRayContainer::const_iterator vcit, vcit_end = vcRays.end();
+                                for (vcit = vcRays.begin(); vcit != vcit_end; ++ vcit)
+                                {
+                                        VssRay *ray = *vcit;
+                                        //Intersectable *obj = ray->mTerminationObject;
+                                        Intersectable *obj = mHierarchyManager->GetIntersectable(*ray, true);
+                                        
+                                        if (obj && !obj->Mailed())
+                                        {
+                                                obj->Mail();
+                                        //      exporter->ExportIntersectable(obj);
+                                        }
+                                }
                         }
-                
-                        // associate new rays with output view cell
-                        if (0)
-                        {
-                                VssRayContainer vcRays;
-                                raysOut = min((int)rays.size(), mVisualizationSamples);
-
-                                // check whether we can add the current ray to the output rays
-                                for (int k = 0; k < raysOut; ++ k)
-                                {
-                                        VssRay *ray = rays[k];
-                                        for     (int j = 0; j < (int)ray->mViewCells.size(); ++ j)
-                                        {
-                                                ViewCell *rayvc = ray->mViewCells[j];
-        
-                                                if (rayvc == vc)
-                                                        vcRays.push_back(ray);
-                                        }
-                                }       
-                                
-                                // export rays piercing this view cell
-                                exporter->ExportRays(vcRays, RgbColor(1, 1, 0));
-                        }
-                }
-
+                }
 
                 /////////////////
@@ -5259 +5262 @@
                 exporter->SetFilled();
 
-#if 0   
-                //////////
-                //-- export pvs
-
-                Intersectable::NewMail();
-                KdLeaf::NewMail();
-
-                vector<KdLeaf *> kdLeaves;
-
-                ObjectPvsMap::const_iterator oit, oit_end = pvs.mEntries.end();
-
-                for (oit = pvs.mEntries.begin(); oit != oit_end; ++ oit)
-                {       
-                        Intersectable *obj = (*oit).first;
-
-                        if (obj->Type() == Intersectable::KD_INTERSECTABLE)
-                        {
-                                m.mDiffuseColor = RgbColor(1, 1, 1);
-                                exporter->SetForcedMaterial(m);
-
-                                // export bounding box of node
-                                KdIntersectable *kdObj  = dynamic_cast<KdIntersectable *>(obj);
-                                AxisAlignedBox3 box = mOspTree->GetBoundingBox(kdObj->GetItem());
-
-                                exporter->SetWireframe();
-                                exporter->ExportBox(box);
-                                exporter->SetFilled();
-                        }
-
-                        m.mDiffuseColor = RgbColor(1, 0, 0);
-                        exporter->SetForcedMaterial(m);
-
-                        // export pvs entry
-                        if (!obj->Mailed())
-                        {
-                                exporter->ExportIntersectable(obj);
-                                obj->Mail();
-                        }
-                }               
-#endif
-        
                 DEL_PTR(exporter);
                 cout << "finished" << endl;
@@ -5398 +5360 @@
         if (!ViewCellsConstructed())
                 return NULL;
-
         if (!mViewSpaceBox.IsInside(point))
-          return NULL;
-
+                return NULL;
         return mHierarchyManager->GetVspTree()->GetViewCell(point, active);
 }

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

@@ -1281 +1281 @@
                 if (madeContrib)
                         ++ contributingSamples;
-                
-                // note: vss rays are never deleted
-                if (0) leaf->mVssRays.push_back(new VssRay(*ray));
         }
 }

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

@@ -305 +305 @@
 {
         DEL_PTR(mPvs);
-        CLEAR_CONTAINER(mVssRays);
+
+        VssRayContainer::const_iterator vit, vit_end = mVssRays.end();
+        for (vit = mVssRays.begin(); vit != vit_end; ++ vit)
+        {
+                VssRay *ray = *vit;
+                ray->Unref();
+
+                if (!ray->IsActive())
+                        delete ray;
+        }
+        //CLEAR_CONTAINER(mVssRays);
 }
 
@@ -357 +367 @@
 mRoot(NULL),
 mOutOfBoundsCell(NULL),
-mStoreRays(false),
+mStoreRays(true),
 mTimeStamp(1),
 mHierarchyManager(NULL)
@@ -588 +598 @@
         }
 
-
-        //-- store additional info
         if (mStoreRays)
         {
+                ///////////
+                //-- store sampling rays
                 RayInfoContainer::const_iterator it, it_end = tData.mRays->end();
 
@@ -684 +694 @@
 
 #if 0
+                /////////////
                 //-- store pvs optained from rays
                 AddSamplesToPvs(leaf, *tData.mRays, sampCon, conSamp);
@@ -694 +705 @@
                 mVspStats.sampleContributions += (int)sampCon;
 #endif
-                //-- store additional info
                 if (mStoreRays)
                 {
+                        //////////
+                        //-- store rays piercing this view cell
                         RayInfoContainer::const_iterator it, it_end = tData.mRays->end();
                         for (it = tData.mRays->begin(); it != it_end; ++ it)
@@ -702 +714 @@
                                 (*it).mRay->Ref();                      
                                 leaf->mVssRays.push_back((*it).mRay);
+                                //leaf->mVssRays.push_back(new VssRay(*(*it).mRay));
                         }
                 }
@@ -767 +780 @@
         VspLeaf *leaf = dynamic_cast<VspLeaf *>(tData.mNode);
         
-        ////////////////////////////////////////////////////////
-        //-- the front and back traversal data are filled with the new values
+        ///////////////
+        //-- new traversal values
 
         frontData.mDepth = tData.mDepth + 1;
@@ -782 +795 @@
                           *backData.mRays);
 
+        /////////////
         //-- compute pvs
         frontData.mPvs = EvalPvsSize(*frontData.mRays);
@@ -2741 +2755 @@
                         {
                                 leaf->Mail();
-                                if (leaf->GetSubdivisionCandidate()) // a candidate still attached to this node
+                                 // a candidate still attached to this node
+                                if (leaf->GetSubdivisionCandidate())
                                 {
                                         dirtyList.push_back(leaf->GetSubdivisionCandidate());

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

@@ -331 +331 @@
 
                 bool exportViewCells = false;
-                
                 if (exportViewCells)
                 {
@@ -477 +476 @@
           mViewCellsManager->PrintStatistics(Debug);
   }
-#if 1 
+#if 0
   else 
   {      

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

@@ -238 +238 @@
                 ApplyTransformations(mTransformations, &tempMesh);
 
-                FaceContainer::const_iterator fit, fit_end = tempMesh.mFaces.end();
-
-                for (fit = tempMesh.mFaces.begin(); fit != fit_end; ++ fit)
+                FaceContainer::const_iterator fit, fit_begin = tempMesh.mFaces.begin(), 
+                        fit_end = tempMesh.mFaces.end();
+                
+                for (fit = fit_begin; fit != fit_end; ++ fit)
                 {
                         //cout << "f";
@@ -253 +254 @@
                         for (tit = triangles.begin(); tit != tit_end; ++ tit)
                         {
-                                //cout << "triangle: " << *tit << endl;
                                 TriangleIntersectable *ti = new TriangleIntersectable(*tit);
                                 mCurrentNode->mGeometry.push_back(ti);

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

@@ -163 +163 @@
         }
 
-        string rayCastFile = ReplaceSuffix(filename, ".obj", ".kdf");
+
+        string externKdTree = ReplaceSuffix(filename, ".obj", ".kdf");
+        char internKdTree[100];
+        Environment::GetSingleton()->GetStringValue("Preprocessor.kdTreeFilename", internKdTree);
 
         //-- initialize external ray casters
-        if (preprocessor->InitRayCast(rayCastFile))
+        if (preprocessor->InitRayCast(externKdTree, internKdTree))
         {
                 cout << "ray casting initialized!" << endl;
@@ -175 +178 @@
                 Cleanup();
                 exit(1);
+        }
+
+        // export kd tree?
+        bool exportKdTree;
+        Environment::GetSingleton()->GetBoolValue("Preprocessor.exportKdTree", exportKdTree);
+        if (exportKdTree)
+        {
+                const long startTime = GetTime();
+                cout << "exporting kd tree ... ";
+
+                if (!preprocessor->ExportKdTree(internKdTree))
+                {
+                        cout << " error exporting kd tree with filename " << internKdTree << endl;
+                }
+                else
+                {
+                        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
+                }
         }
 
@@ -198 +219 @@
 #endif
 
-        
         bool guiSupported = false;
         if (preprocessor->mUseGlRenderer || preprocessor->mUseGlDebugger)