Changeset 870 for GTP/trunk

Timestamp:

05/02/06 10:26:43 (19 years ago)

Author:

mattausch

Message:

added pvs

Location:

GTP/trunk/Lib/Vis

Files:

• OnlineCullingCHC/IVReader/src/ivmanualmeshloader.cpp (modified) (1 diff)
• OnlineCullingCHC/OGRE/include/OgreMeshInstance.h (added)
• OnlineCullingCHC/OGRE/include/OgreVisibilityOctreeSceneManager.h (modified) (3 diffs)
• OnlineCullingCHC/OGRE/src/OgreMeshInstance.cpp (added)
• OnlineCullingCHC/OGRE/src/OgreVisibilityOctreeSceneManager.cpp (modified) (14 diffs)
• OnlineCullingCHC/OGRE/src/OgreVisibilitySceneManagerDll.cpp (modified) (1 diff)
• OnlineCullingCHC/include/VisibilityEnvironment.h (modified) (3 diffs)
• OnlineCullingCHC/scripts/GtpVisibility.vcproj (modified) (1 diff)
• OnlineCullingCHC/src/VisibilityEnvironment.cpp (modified) (2 diffs)
• Preprocessing/data/vienna/city1500_flat_1.x3d (added)
• Preprocessing/src/AxisAlignedBox3.h (modified) (2 diffs)
• Preprocessing/src/Intersectable.h (modified) (1 diff)
• Preprocessing/src/Mesh.cpp (modified) (1 diff)
• Preprocessing/src/Mesh.h (modified) (2 diffs)
• Preprocessing/src/Preprocessor.cpp (modified) (1 diff)
• Preprocessing/src/ViewCell.cpp (modified) (1 diff)
• Preprocessing/src/ViewCellsManager.cpp (modified) (2 diffs)
• Preprocessing/src/ViewCellsManager.h (modified) (3 diffs)
• Preprocessing/src/ViewCellsParser.cpp (modified) (15 diffs)
• Preprocessing/src/VspBspTree.cpp (modified) (3 diffs)
• Preprocessing/src/VspBspTree.h (modified) (2 diffs)
• Preprocessing/src/X3dParser.cpp (modified) (1 diff)
• shared/scripts/GtpVisibility.suo (modified) (previous)

GTP/trunk/Lib/Vis/OnlineCullingCHC/IVReader/src/ivmanualmeshloader.cpp

@@ -146 +146 @@
                 
         AxisAlignedBox bb(data->boundingBox->getMinimum() - translation, data->boundingBox->getMaximum() - translation);
+        //AxisAlignedBox bb(data->boundingBox->getMinimum(), data->boundingBox->getMaximum());
         pMesh->_setBounds(bb); 
         Real radius = data->boundingBox->getMinimum().length();

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreVisibilityOctreeSceneManager.h

@@ -123 +123 @@
         /** Finds object corresponding to this bounding box in the scene.
         */
-        MovableObject *FindCorrespondingObject(const AxisAlignedBox &box);
+        Entity *FindCorrespondingObject(const AxisAlignedBox &box);
 
         /** Identifies objects in the scene and gives them unique ids that
@@ -129 +129 @@
         */
         void IdentifyObjects(GtpVisibilityPreprocessor::ObjectContainer &objects);
+
+        /** Loads / unloads pvs of the view cell to set the visibility in the scene.
+        */
+        void applyViewCellPvs(GtpVisibilityPreprocessor::ViewCell *vc, const bool load);
+
+        /** updates pvs in current frame.
+        */
+        void updatePvs(Camera *cam);
+
+        /** Sets all objects invisible.
+        */
+        void SetObjectsVisible(const bool visible);
 
         /// the interface to the scene hierarchy.
@@ -183 +195 @@
         bool mViewCellsLoaded;
         GtpVisibilityPreprocessor::ViewCellsManager *mViewCellsManager;
+
+        /** Used to assign Ogre meshes to view cell entries.
+        */
+        GtpVisibilityPreprocessor::ObjectContainer mObjects;
+
+        GtpVisibilityPreprocessor::ViewCell *mOldViewCell;
+        GtpVisibilityPreprocessor::ViewCell *mCurrentViewCell;
+
+        /** If view cells are used.
+        */
+        bool mUseViewCells;
 };
 

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityOctreeSceneManager.cpp

@@ -15 +15 @@
 #include <OgreConfigFile.h>
 #include "OgreTypeConverter.h"
+#include "OgreMeshInstance.h"
+#include "common.h"
 
 // normal terrain rendering
@@ -42 +44 @@
 mExecuteVertexProgramForAllPasses(true),
 mIsHierarchicalCulling(false),
-mViewCellsLoaded(false)
+mViewCellsLoaded(false),
+mCurrentViewCell(NULL),
+mOldViewCell(NULL),
+mUseViewCells(false)
 {
         mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
@@ -85 +90 @@
 {
         OGRE_DELETE(mHierarchyInterface);
+        CLEAR_CONTAINER(mObjects);
 }
 //-----------------------------------------------------------------------
@@ -127 +133 @@
     }
         // add bounding boxes of rendered objects
+        if (0)
         for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it)
 {
@@ -145 +152 @@
                         {
                                 // render the leaf nodes
-                                if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0) && 
-                                         (*it)->getAttachedObject(0)->getMovableType() == "Entity")
+                                if ((*it)->numAttachedObjects() && 
+                                        !(*it)->numChildren() && 
+                                        ((*it)->getAttachedObject(0)->getMovableType() == "Entity") &&
+                                        (*it)->getAttachedObject(0)->isVisible())
                                 {
                                         getRenderQueue()->addRenderable((*it));
-                                        std::stringstream d;
-                                        d << "here 223 " <<  (*it)->getAttachedObject(0)->getWorldBoundingBox();
-                                        Ogre::LogManager::getSingleton().logMessage(d.str());
                                 }
-
-                                // addbounding boxes instead of node itself
-                                //(*it)->_addBoundingBoxToQueue(getRenderQueue());
                         }
                         // add renderables itself
@@ -247 +250 @@
                 return;
         }
+        
 
         //-- show visible scene nodes and octree bounding boxes from last frame
@@ -265 +269 @@
                         OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
                 }
+
                 // only shadow casters will be rendered in shadow texture pass
                 if (0) mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
+
+
+                //-- apply view cell pvs
+                updatePvs(cam);
         }
         
@@ -311 +320 @@
         else //-- the hierarchical culling algorithm
         {       
-                // this is also called in TerrainSceneManager: really
-                // nexessary?
+                // this is also called in TerrainSceneManager: really necessary?
                 //mDestRenderSystem -> setLightingEnabled(false);
 
@@ -498 +506 @@
                 if (!mViewCellsLoaded)
                 {
-                        LoadViewCells("");
-                        mViewCellsLoaded = true;
-                }
-
-                return true;
-        }
-
+                        LoadViewCells(static_cast<const char *>(val));
+                        mViewCellsLoaded = true;        
+                }
+
+                return true;
+        }
+        if (key == "UseViewCells")
+        { 
+                if (mViewCellsLoaded)
+                {
+                        mUseViewCells = *static_cast<const bool *>(val);
+                        
+                        if (mUseViewCells)
+                        {
+                                SetObjectsVisible(false);
+                                mCurrentViewCell = mOldViewCell = NULL;
+                        }
+                        else
+                        {
+                                SetObjectsVisible(true);
+                        }
+                }
+
+                return true;
+        }
         return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
                 setOption(key, val) || OctreeSceneManager::setOption(key, val);
@@ -876 +902 @@
    }
 }
-//-----------------------------------------------------------------------
-MovableObject *VisibilityOctreeSceneManager::FindCorrespondingObject(const AxisAlignedBox &box)
+
+inline static AxisAlignedBox EnlargeBox(const AxisAlignedBox &box)
+{
+        const float eps = 1e-3f;
+        const Vector3 veps(eps, eps, eps);
+        Vector3 max = box.getMaximum();
+        Vector3 min = box.getMinimum();
+
+        return AxisAlignedBox(min - veps, max + veps);
+}
+//-----------------------------------------------------------------------
+Entity *VisibilityOctreeSceneManager::FindCorrespondingObject(const AxisAlignedBox &box)
 {
         list<SceneNode *> sceneNodeList;
-
-        findNodesIn(box, sceneNodeList, NULL);
-        std::stringstream d; 
-        d << "\n*******************";
-        Ogre::LogManager::getSingleton().logMessage(d.str());
+        AxisAlignedBox mybox = EnlargeBox(box);
+        //AxisAlignedBox dummy(Vector3(-50000, -50000, -50000), Vector3(50000, 50000, 50000));
+        
+        // get intersecting scene nodes
+        findNodesIn(mybox, sceneNodeList, NULL);
+        
+
         list<SceneNode *>::const_iterator sit, sit_end = sceneNodeList.end();
 
-        float overlap = GtpVisibilityPreprocessor::Limits::Small;
-
-        
-        d << "here23 " << box;
-        Ogre::LogManager::getSingleton().logMessage(d.str());
-
-        MovableObject *bestFittingObj = NULL;
+        float overlap = 0;//GtpVisibilityPreprocessor::Limits::Small;
+
+        Entity *bestFittingObj = NULL;
         float bestFit = overlap;
 
@@ -908 +942 @@
         while (oit.hasMoreElements())
                 {
-                         MovableObject *mo = oit.getNext();
-                         const AxisAlignedBox bbox = mo->getWorldBoundingBox(true);
-                        
-                         overlap = RatioOfOverlap(OgreTypeConverter::ConvertFromOgre(box),
-                                                                          OgreTypeConverter::ConvertFromOgre(bbox));
+                        MovableObject *mo = oit.getNext();
+
+                        // we are only interested in scene entities
+                        if (mo->getMovableType() != "Entity")
+                        {
+                                continue;
+                        }
+                         
+                        const AxisAlignedBox bbox = EnlargeBox(mo->getWorldBoundingBox());
+                                        
+
+                        // compute measure how much aabbs overlap
+                        overlap = RatioOfOverlap(OgreTypeConverter::ConvertFromOgre(mybox),
+                                                                         OgreTypeConverter::ConvertFromOgre(bbox));
+        
                          if (overlap > bestFit)
                          {
                                  bestFit = overlap;
-                                 bestFittingObj = mo;
-                                d << "new bestfit " << bestFit << endl;Ogre::LogManager::getSingleton().logMessage(d.str());
-                                 // perfect fit => object found
+                        
+                                 bestFittingObj = static_cast<Entity *>(mo);
+
+                                 // perfect fit => object found, eraly exit
                                  if (overlap >= thresh)
-                                 {
-                                         std::stringstream d2; 
-        
-                        d2 << "!!best fit " << bestFittingObj->getWorldBoundingBox(true);
-        Ogre::LogManager::getSingleton().logMessage(d2.str());
-                                        return bestFittingObj;
-                                        }
+                                         return bestFittingObj;                         
                          }
                 }
         }
 
-        std::stringstream d2; 
-        if (bestFittingObj)
-        {
-                d2 << "best fit " << bestFittingObj->getWorldBoundingBox(true);
-        }
-        else
-        {
-                d2 << "warning, no best fitting objects";
-        }
-
-        Ogre::LogManager::getSingleton().logMessage(d2.str());
+        if (0)
+        {
+                std::stringstream d; 
+                if (bestFittingObj)
+                        d << "best fit: " << bestFit;     
+                else
+                        d << "warning, objects do not fit\n" << box;
+        
+                Ogre::LogManager::getSingleton().logMessage(d.str());
+        }
 
         return bestFittingObj;
@@ -948 +986 @@
 void VisibilityOctreeSceneManager::LoadViewCells(string filename)
 {
-        GtpVisibilityPreprocessor::ObjectContainer objects;
+        // the objects are set to invisible a prioriy
+        SetObjectsVisible(false);
+
         // identify the corresponding Ogre meshes using the bounding boxes
-        IdentifyObjects(objects);
+        IdentifyObjects(mObjects);
 
         // load the view cells assigning the found objects to the pvss
-        //mViewCellsManager->LoadViewCells(filename, &objects);
+        mViewCellsManager = 
+                GtpVisibilityPreprocessor::ViewCellsManager::LoadViewCells(filename, &mObjects);
+
+        std::stringstream d;
+        d << "view cells loaded" << endl;
+        Ogre::LogManager::getSingleton().logMessage(d.str());
 }
 //-----------------------------------------------------------------------
@@ -970 +1015 @@
                   const GtpVisibilityPreprocessor::AxisAlignedBox3 box = (*iit).second;
                   const AxisAlignedBox currentBox = OgreTypeConverter::ConvertToOgre(box);
-                  
-                  MovableObject *mo = FindCorrespondingObject(currentBox);
-
-                  //objects.push_back(mi);
-        }
-}
-
+                 
+                  Entity *ent = FindCorrespondingObject(currentBox);
+
+                  // create new mesh instance
+                  OgreMeshInstance *omi = new OgreMeshInstance(ent);
+                  omi->SetId((*iit).first);
+                  objects.push_back(omi);
+        }
+}
 //-------------------------------------------------------------------------
-void VisibilityOctreeSceneManager::loadVisibilityConfig(const String& filename)
-{
-        /// Set up the options
+void VisibilityOctreeSceneManager::applyViewCellPvs(GtpVisibilityPreprocessor::ViewCell *vc, 
+                                                                                                        const bool load)
+{       GtpVisibilityPreprocessor::Debug << "here9 " << endl;
+        // NOTE: should not happen, rather apply view cell representing unbounded space then
+        if (!vc) return;
+
+        GtpVisibilityPreprocessor::ObjectPvsMap::const_iterator oit,
+                        oit_end = vc->GetPvs().mEntries.end();
+
+        //-- PVS of view cell
+        for (oit = vc->GetPvs().mEntries.begin(); oit != oit_end; ++ oit)
+        {
+                if (!(*oit).first) continue;
+
+                OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance*>((*oit).first);
+                omi->GetMesh()->setVisible(load);
+                GtpVisibilityPreprocessor::Debug << "here45 " << omi->GetId() << endl;
+        }
+}
+//-------------------------------------------------------------------------
+void VisibilityOctreeSceneManager::SetObjectsVisible(const bool visible)
+{
+        // for OGRE 1.2
+#ifdef OGRE12
+        MovableObjectIterator mit = getMovableObjectIterator("Entity");
+#else
+        EntityIterator eit = getEntityIterator();
+
+        // set all objects to invisible (initially);
+        while (eit.hasMoreElements())
+        {
+                Entity *ent = eit.getNext();
+                ent->setVisible(visible);
+        }
+
+#endif
+}
+//-------------------------------------------------------------------------
+void VisibilityOctreeSceneManager::loadVisibilityConfig(const String &filename)
+{
+        // TODO matt
+        // Set up the options
         ConfigFile config;
         String val;
@@ -1000 +1086 @@
         }
 }
+//-------------------------------------------------------------------------
+void VisibilityOctreeSceneManager::updatePvs(Camera *cam)
+{
+        Ogre::LogManager::getSingleton().logMessage("here196");
+        if (mViewCellsLoaded && mUseViewCells)
+        {
+                GtpVisibilityPreprocessor::ViewCell *vc = 
+                        mViewCellsManager->GetViewCell(OgreTypeConverter::ConvertFromOgre(cam->getDerivedPosition()));
+
+                std::stringstream d; d << "pos " << cam->getDerivedPosition() << "vc: " << vc;
+                Ogre::LogManager::getSingleton().logMessage(d.str());
+
+                // view cell changed => unload old objects and load new objects
+                if (vc != mCurrentViewCell)
+                {
+                        //-- unload old pvs
+                        if (mOldViewCell)
+                        {
+                                const bool load = false;
+
+                                applyViewCellPvs(mOldViewCell, load);
+                                Ogre::LogManager::getSingleton().logMessage("here16");
+                        }
+
+                        mOldViewCell = mCurrentViewCell;
+
+                        //-- load new pvs
+                        mCurrentViewCell = vc;
+                        const bool load = true;
+
+                        applyViewCellPvs(mCurrentViewCell, load);
+                        Ogre::LogManager::getSingleton().logMessage("here106");
+                }
+        }
+}
+
 }  // namespace Ogre

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilitySceneManagerDll.cpp

@@ -49 +49 @@
 {
         visEnv = new GtpVisibility::VisibilityEnvironment();
+        visEnv->LoadEnvironment("vienna_simple.env");
         visManager = new GtpVisibility::VisibilityManager(visEnv);
 

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/VisibilityEnvironment.h

@@ -1 +1 @@
 #ifndef _VisibilityEnvironment_H__
 #define _VisibilityEnvironment_H__
+
+#include <string>
 
 namespace GtpVisibility {
@@ -10 +12 @@
 public:
     VisibilityEnvironment();
-        
+        ~VisibilityEnvironment();
         /** Different types of occlusion culling algorithms 
         */
@@ -20 +22 @@
         /** Loads an environment from disk.
         */
-        void LoadEnvironment();
+        void LoadEnvironment(std::string filename);
 };
 } // namespace GtpVisibility

GTP/trunk/Lib/Vis/OnlineCullingCHC/scripts/GtpVisibility.vcproj

@@ -63 +63 @@
                                 Name="VCCLCompilerTool"
                                 OptimizeForWindowsApplication="TRUE"
-                                AdditionalIncludeDirectories="..\include;"$(OGRE_PATH)\OgreMain\include""
+                                AdditionalIncludeDirectories="..\include;"$(OGRE_PATH)\OgreMain\include";..\..\Preprocessing\src"
                                 PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
                                 RuntimeLibrary="2"

GTP/trunk/Lib/Vis/OnlineCullingCHC/src/VisibilityEnvironment.cpp

@@ -1 +1 @@
 #include "VisibilityEnvironment.h"
+#include "common.h"
+#include "Environment.h"
+
 
 namespace GtpVisibility {
@@ -6 +9 @@
 VisibilityEnvironment::VisibilityEnvironment()
 {
+        // load debug stream
+        GtpVisibilityPreprocessor::Debug.open("debug.log");
+         
+}
+VisibilityEnvironment::~VisibilityEnvironment()
+{
+        // load debug stream
+        DEL_PTR(GtpVisibilityPreprocessor::environment);
+         
 }
 //-----------------------------------------------------------------------
-void VisibilityEnvironment::LoadEnvironment()
+void VisibilityEnvironment::LoadEnvironment(string filename)
 {
+        // todo matt:
+        GtpVisibilityPreprocessor::environment = new GtpVisibilityPreprocessor::Environment;
+        
+        char argc = 2;
+        char *argv[2];
+        argv[0] = "";
+        
+        char fname[200];
+        sprintf(fname, "%s", filename.c_str());
+        argv[1] = fname;
+
+        GtpVisibilityPreprocessor::Debug << "filename: " << argv[1] << endl;
+
+        GtpVisibilityPreprocessor::environment->Parse(argc, argv, false);
+        //MeshKdTree::ParseEnvironment();
 }
 
+
 } // namespace GtpVisibility

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

@@ -142 +142 @@
         between 0 (no overlap) and 1 (same box).
   */
-  friend inline float FactorOfOverlap(const AxisAlignedBox3 &, const AxisAlignedBox3 &);
+  friend inline float RatioOfOverlap(const AxisAlignedBox3 &, const AxisAlignedBox3 &);
 
   /** Includes returns true if a includes b (completely)
@@ -540 +540 @@
 }
 
-inline float FactorOfOverlap(const AxisAlignedBox3 &box1, const AxisAlignedBox3 &box2)
-{
-        const AxisAlignedBox3 isect = Intersect(box1, box2);
-        return isect.GetVolume() / box1.GetVolume();
+inline float RatioOfOverlap(const AxisAlignedBox3 &box1, const AxisAlignedBox3 &box2)
+{
+        // return ratio of intersection to union
+        const AxisAlignedBox3 bisect = Intersect(box1, box2);
+        const AxisAlignedBox3 bunion = Union(box1, box2);
+
+        return bisect.GetVolume() / bunion.GetVolume();
 }
 

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

@@ -49 +49 @@
 
     virtual AxisAlignedBox3 GetBox() = 0;
-        virtual int CastRay(Ray &ray) = 0;
+        virtual int CastRay(GtpVisibilityPreprocessor::Ray &ray) = 0;
         
         virtual bool IsConvex() = 0;

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

@@ -69 +69 @@
 Mesh::Preprocess()
 {
- Cleanup();
+        Cleanup();
    
-   ComputeBoundingBox();
+        ComputeBoundingBox();
    
-  /** true if it is a watertight convex mesh */
-  mIsConvex = false;
-  
-  if (mFaces.size() > MeshKdTree::mTermMinCost) {
-    mKdTree = new MeshKdTree(this);
-    MeshKdLeaf *root = (MeshKdLeaf *)mKdTree->GetRoot();
-    for (int i = 0; i < mFaces.size(); i++)
-      root->mFaces.push_back(i);
-    cout<<"KD";
-    mKdTree->Construct();
-        
-    if (mKdTree->GetRoot()->IsLeaf()) {
-      cout<<"d";
-      delete mKdTree;
-          mKdTree = NULL;
-    }
-  }
+        /** true if it is a watertight convex mesh 
+        */
+        mIsConvex = false;
+
+        if (mFaces.size() > MeshKdTree::mTermMinCost) 
+        {
+                mKdTree = new MeshKdTree(this);
+                MeshKdLeaf *root = (MeshKdLeaf *)mKdTree->GetRoot();
+                
+                for (int i = 0; i < mFaces.size(); i++)
+                        root->mFaces.push_back(i);
+                
+                cout<<"KD";
+                mKdTree->Construct();
+
+                if (mKdTree->GetRoot()->IsLeaf()) 
+                {
+                        cout<<"d";
+                        delete mKdTree;
+                        mKdTree = NULL;
+                }
+        }
 }
 

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

@@ -22 +22 @@
 
 /// vertex index container
-typedef std::vector<short> VertexIndexContainer;
-
+//typedef std::vector<short> VertexIndexContainer;
+typedef std::vector<int> VertexIndexContainer;
 
 /** Patch used as an element of the mesh */
@@ -58 +58 @@
 /// default vertex container for Mesh
 typedef vector<Vector3> VertexContainer;
-
-/// vertex index container
-typedef vector<short> VertexIndexContainer;
 
 /// default patch container for Mesh

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

@@ -374 +374 @@
                 Debug << "view cell type: VspBsp" << endl;
 
-                mVspBspTree = new VspBspTree();
+                mVspBspTree = new VspBspTree(environment);
                 mViewCellsManager = new VspBspViewCellsManager(mVspBspTree);
         }

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

@@ -2033 +2033 @@
                 stream << "active=\"" << viewCell->IsActive() << "\" ";
                 stream << "mergecost=\"" << viewCell->GetMergeCost() << "\" ";
+                stream << "pvs=\"";
+
+                //-- NOTE: do not export pvss for interior view cells because
+                // they can be completely reconstructed from the leaf pvss
+                if (0)
+                        ExportPvs(viewCell, stream);
                 
-                //-- NOTE: do not export pvss for interior view cells because
-                // they can be compeletely reconstructed from the leaf pvss
-                if (0)
-                {
-                        stream << "pvs=\"";
-                        ExportPvs(viewCell, stream);
-                }
-
                 stream << "\" >" << endl;
 

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

@@ -4683 +4683 @@
         ViewCellsManager *vm = NULL;
 
+        Debug << "vc filename: " << filename << endl;
+
         if (parser.ParseFile(filename, &vm, objects))
         {
@@ -4699 +4701 @@
         else
         {
-                Debug << "failed loading view cells" << endl;
+                Debug << "Error: loading view cells failed!" << endl;
                 DEL_PTR(vm);
         }

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

@@ -362 +362 @@
         virtual void FinalizeViewCells(const bool createMesh);
 
-
-        /** Loads view cells from file. The view cells manager is created with 
-                respect to the loaded view cells.
-
-                @returns the view cells manager if loading was successful, false otherwise
-        */
-        static ViewCellsManager *LoadViewCells(const string filename, 
-                                                                                   ObjectContainer *objects);
-
         /** Evaluates statistics values on view cells.
         */
@@ -432 +423 @@
                                 );
 
-  AxisAlignedBox3
-  GetViewCellBox(ViewCell *vc);
+        /** Returns bounding box of a view cell.
+        */
+        AxisAlignedBox3 GetViewCellBox(ViewCell *vc);
 
         /** Exports bounding boxes of objects to file.
@@ -442 +434 @@
         */
         bool LoadBoundingBoxes(const string filename, IndexedBoundingBoxContainer &boxes) const;
+
+
+        /** Loads view cells from file. The view cells manager is created with 
+                respect to the loaded view cells.
+
+                @returns the view cells manager if loading was successful, false otherwise
+        */
+        static ViewCellsManager *LoadViewCells(const string filename, ObjectContainer *objects);
 
 protected:

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

@@ -117 +117 @@
         // go one up in the tree
         if (mCurrentBspNode->GetParent())
-        {       cout << "]";
+        {       Debug << "]";
                 mCurrentBspNode = mCurrentBspNode->GetParent();
         }
@@ -127 +127 @@
         // go one up in the tree
         if (mCurrentViewCell->GetParent())
-        {       cout << "]";
+        {       Debug << "]";
                 mCurrentViewCell = mCurrentViewCell->GetParent();
         }
@@ -160 +160 @@
                         const char *ptr = attrValue.LocalForm();
                         
+                        //-- the view cells manager is created here
                         CreateViewCellsManager(ptr);
                 }
@@ -171 +172 @@
         if (element == "Interior") 
         {
-                cout << "[";
+                Debug << "[";
                 StartBspInterior(attributes);
         }
@@ -177 +178 @@
         if (element == "Leaf") 
         {
-                cout << "l";
+                Debug << "l";
                 Debug << "leaf" << endl;
                 StartBspLeaf(attributes);
@@ -189 +190 @@
         StrX lname(name);
         string element(lname.LocalForm());
-
+        
         // decides the used view cell hierarchy
         if (element == "ViewCells")
         {
-                cout << "parsing view cells" << endl;
+                Debug << "parsing view cells" << endl;
                 mParseViewCells = true;
         }
@@ -199 +200 @@
         if (element == "Hierarchy")
         {
-                cout << "parsing spatial hierarchy" << endl;
+                Debug << "parsing spatial hierarchy" << endl;
                 mParseViewCells = false;
                 StartHierarchy(attributes);
@@ -207 +208 @@
         if (element == "ViewSpaceBox")
         {
-                cout << "b";
+                Debug << "b";
                 StartViewSpaceBox(attributes);
         }
@@ -234 +235 @@
                 if (element == "Interior") 
                 {
-                        cout << "[";
+                        Debug << "[";
                         StartViewCellInterior(attributes);
                 }
@@ -240 +241 @@
                 if (element == "Leaf") 
                 {
-                        cout << "l";
+                        Debug << "l";
                         StartViewCellLeaf(attributes);
                 }
@@ -306 +307 @@
                                   // to sumof pdfs, i.e. its relative visibility
                                   // temporarily set to 1.0f
-                                        viewCell->GetPvs().AddSample(obj, 1.0f);
+                                        viewCell->GetPvs().AddSample(obj, 1.0f);                                
                                 }
                                 else
@@ -559 +560 @@
                 mVspBspTree = new VspBspTree();
                 //mCurrentBspNode = mVspBspTree->GetRoot();
-
                 mViewCellsManager = new VspBspViewCellsManager(mVspBspTree);
 
@@ -573 +573 @@
         else
         {
-                cerr<<"Wrong view cells type " << name << "!!!" << endl;
+                cerr << "Wrong view cells type: " << name << endl;
                 exit(1);
         }
@@ -700 +700 @@
     catch (const XMLException& e)
       {
-        XERCES_STD_QUALIFIER cerr << "\nError during parsing: \n"
+                        XERCES_STD_QUALIFIER cerr << "\nError during parsing: \n"
                                   << StrX(e.getMessage())
                                   << "\n" << XERCES_STD_QUALIFIER endl;
-        errorCount = 1;
-        return false;
+                        errorCount = 1;
+                        return false;
       }
 
@@ -710 +710 @@
     // Print out the stats that we collected and time taken
     if (!errorCount) {
-      XERCES_STD_QUALIFIER cout << filename << ": " << duration << " ms ("
+                XERCES_STD_QUALIFIER cerr << filename << ": " << duration << " ms ("
                                 << handler.GetElementCount() << " elems, "
                                 << handler.GetAttrCount() << " attrs, "

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

@@ -55 +55 @@
 
 
-VspBspTree::VspBspTree():
+VspBspTree::VspBspTree(Environment *env):
 mRoot(NULL),
 mUseAreaForPvs(false),
@@ -67 +67 @@
 {
         bool randomize = false;
-        environment->GetBoolValue("VspBspTree.Construction.randomize", randomize);
+        env->GetBoolValue("VspBspTree.Construction.randomize", randomize);
         if (randomize)
                 Randomize(); // initialise random generator for heuristics
 
         //-- termination criteria for autopartition
-        environment->GetIntValue("VspBspTree.Termination.maxDepth", mTermMaxDepth);
-        environment->GetIntValue("VspBspTree.Termination.minPvs", mTermMinPvs);
-        environment->GetIntValue("VspBspTree.Termination.minRays", mTermMinRays);
-        environment->GetFloatValue("VspBspTree.Termination.minProbability", mTermMinProbability);
-        environment->GetFloatValue("VspBspTree.Termination.maxRayContribution", mTermMaxRayContribution);
-        environment->GetFloatValue("VspBspTree.Termination.minAccRayLenght", mTermMinAccRayLength);
-        environment->GetFloatValue("VspBspTree.Termination.maxCostRatio", mTermMaxCostRatio);
-        environment->GetIntValue("VspBspTree.Termination.missTolerance", mTermMissTolerance);
-        environment->GetIntValue("VspBspTree.Termination.maxViewCells", mMaxViewCells);
+        env->GetIntValue("VspBspTree.Termination.maxDepth", mTermMaxDepth);
+        env->GetIntValue("VspBspTree.Termination.minPvs", mTermMinPvs);
+        env->GetIntValue("VspBspTree.Termination.minRays", mTermMinRays);
+        env->GetFloatValue("VspBspTree.Termination.minProbability", mTermMinProbability);
+        env->GetFloatValue("VspBspTree.Termination.maxRayContribution", mTermMaxRayContribution);
+        env->GetFloatValue("VspBspTree.Termination.minAccRayLenght", mTermMinAccRayLength);
+        env->GetFloatValue("VspBspTree.Termination.maxCostRatio", mTermMaxCostRatio);
+        env->GetIntValue("VspBspTree.Termination.missTolerance", mTermMissTolerance);
+        env->GetIntValue("VspBspTree.Termination.maxViewCells", mMaxViewCells);
 
         //-- max cost ratio for early tree termination
-        environment->GetFloatValue("VspBspTree.Termination.maxCostRatio", mTermMaxCostRatio);
-
-        environment->GetFloatValue("VspBspTree.Termination.minGlobalCostRatio", mTermMinGlobalCostRatio);
-        environment->GetIntValue("VspBspTree.Termination.globalCostMissTolerance", mTermGlobalCostMissTolerance);
+        env->GetFloatValue("VspBspTree.Termination.maxCostRatio", mTermMaxCostRatio);
+
+        env->GetFloatValue("VspBspTree.Termination.minGlobalCostRatio", mTermMinGlobalCostRatio);
+        env->GetIntValue("VspBspTree.Termination.globalCostMissTolerance", mTermGlobalCostMissTolerance);
 
         // HACK//mTermMinPolygons = 25;
 
         //-- factors for bsp tree split plane heuristics
-        environment->GetFloatValue("VspBspTree.Factor.pvs", mPvsFactor);
-        environment->GetFloatValue("VspBspTree.Termination.ct_div_ci", mCtDivCi);
+        env->GetFloatValue("VspBspTree.Factor.pvs", mPvsFactor);
+        env->GetFloatValue("VspBspTree.Termination.ct_div_ci", mCtDivCi);
 
 
         //-- partition criteria
-        environment->GetIntValue("VspBspTree.maxPolyCandidates", mMaxPolyCandidates);
-        environment->GetIntValue("VspBspTree.maxRayCandidates", mMaxRayCandidates);
-        environment->GetIntValue("VspBspTree.splitPlaneStrategy", mSplitPlaneStrategy);
-
-        environment->GetFloatValue("VspBspTree.Construction.epsilon", mEpsilon);
-        environment->GetIntValue("VspBspTree.maxTests", mMaxTests);
+        env->GetIntValue("VspBspTree.maxPolyCandidates", mMaxPolyCandidates);
+        env->GetIntValue("VspBspTree.maxRayCandidates", mMaxRayCandidates);
+        env->GetIntValue("VspBspTree.splitPlaneStrategy", mSplitPlaneStrategy);
+
+        env->GetFloatValue("VspBspTree.Construction.epsilon", mEpsilon);
+        env->GetIntValue("VspBspTree.maxTests", mMaxTests);
 
         // if only the driving axis is used for axis aligned split
-        environment->GetBoolValue("VspBspTree.splitUseOnlyDrivingAxis", mOnlyDrivingAxis);
+        env->GetBoolValue("VspBspTree.splitUseOnlyDrivingAxis", mOnlyDrivingAxis);
         
         //-- termination criteria for axis aligned split
-        environment->GetFloatValue("VspBspTree.Termination.AxisAligned.maxRayContribution", 
+        env->GetFloatValue("VspBspTree.Termination.AxisAligned.maxRayContribution", 
                                                                 mTermMaxRayContriForAxisAligned);
-        environment->GetIntValue("VspBspTree.Termination.AxisAligned.minRays",
+        env->GetIntValue("VspBspTree.Termination.AxisAligned.minRays",
                                                          mTermMinRaysForAxisAligned);
 
-        //environment->GetFloatValue("VspBspTree.maxTotalMemory", mMaxTotalMemory);
-        environment->GetFloatValue("VspBspTree.maxStaticMemory", mMaxMemory);
-
-        environment->GetFloatValue("VspBspTree.Construction.renderCostWeight", mRenderCostWeight);
-        environment->GetBoolValue("VspBspTree.usePolygonSplitIfAvailable", mUsePolygonSplitIfAvailable);
-
-        environment->GetBoolValue("VspBspTree.useCostHeuristics", mUseCostHeuristics);
-        environment->GetBoolValue("VspBspTree.useSplitCostQueue", mUseSplitCostQueue);
-        environment->GetBoolValue("VspBspTree.simulateOctree", mCirculatingAxis);
-        environment->GetBoolValue("VspBspTree.useRandomAxis", mUseRandomAxis);
-        environment->GetIntValue("VspBspTree.nodePriorityQueueType", mNodePriorityQueueType);
-
-        environment->GetBoolValue("ViewCells.PostProcess.emptyViewCellsMerge", mEmptyViewCellsMergeAllowed);
+        //env->GetFloatValue("VspBspTree.maxTotalMemory", mMaxTotalMemory);
+        env->GetFloatValue("VspBspTree.maxStaticMemory", mMaxMemory);
+
+        env->GetFloatValue("VspBspTree.Construction.renderCostWeight", mRenderCostWeight);
+        env->GetBoolValue("VspBspTree.usePolygonSplitIfAvailable", mUsePolygonSplitIfAvailable);
+
+        env->GetBoolValue("VspBspTree.useCostHeuristics", mUseCostHeuristics);
+        env->GetBoolValue("VspBspTree.useSplitCostQueue", mUseSplitCostQueue);
+        env->GetBoolValue("VspBspTree.simulateOctree", mCirculatingAxis);
+        env->GetBoolValue("VspBspTree.useRandomAxis", mUseRandomAxis);
+        env->GetIntValue("VspBspTree.nodePriorityQueueType", mNodePriorityQueueType);
+
+        env->GetBoolValue("ViewCells.PostProcess.emptyViewCellsMerge", mEmptyViewCellsMergeAllowed);
         
         char subdivisionStatsLog[100];
-        environment->GetStringValue("VspBspTree.subdivisionStats", subdivisionStatsLog);
+        env->GetStringValue("VspBspTree.subdivisionStats", subdivisionStatsLog);
         mSubdivisionStats.open(subdivisionStatsLog);
 
-        environment->GetFloatValue("VspBspTree.Construction.minBand", mMinBand);
-        environment->GetFloatValue("VspBspTree.Construction.maxBand", mMaxBand);
-        environment->GetBoolValue("VspBspTree.Construction.useDrivingAxisForMaxCost", mUseDrivingAxisForMaxCost);
+        env->GetFloatValue("VspBspTree.Construction.minBand", mMinBand);
+        env->GetFloatValue("VspBspTree.Construction.maxBand", mMaxBand);
+        env->GetBoolValue("VspBspTree.Construction.useDrivingAxisForMaxCost", mUseDrivingAxisForMaxCost);
 
         //-- debug output
@@ -199 +199 @@
 }
 
+VspBspTree::VspBspTree():
+mRoot(NULL),
+mUseAreaForPvs(false),
+mCostNormalizer(Limits::Small),
+mViewCellsManager(NULL),
+mOutOfBoundsCell(NULL),
+mStoreRays(false),
+mRenderCostWeight(0.5),
+mUseRandomAxis(false),
+mTimeStamp(1),
+mEpsilon(1e-6f)
+{
+}
 
 BspViewCell *VspBspTree::GetOutOfBoundsCell()

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

@@ -26 +26 @@
 class Beam;
 class ViewCellsTree;
-
+class Environment;
 
 /**
@@ -199 +199 @@
         VspBspTree();
 
+        
+        /** Constructor creating an empty tree. Loads parameters 
+                from an environment file.
+        */ 
+        VspBspTree(Environment *env);
+
         /** Default destructor.
         */

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

@@ -219 +219 @@
         if (mLoadPolygonsAsMeshes)
         {
-                
-                /*vector<VertexIndexContainer>::const_iterator it, 
-                        it_end = mCurrentVertexIndices.end();
-
-                for (it = mCurrentVertexIndices.begin(); it != it_end; ++ it)
-                {
-                        // only one face per mesh
-                        Mesh *mesh = new Mesh();
-
-                        VertexIndexContainer vc;
-
-                        // add vertices
-                        for (int i = 0; i < (int)(*it).size(); ++ i)
-                        {
-                                mesh->mVertices.push_back(mCurrentVertices[(*it)[i]]);
-                                vc.push_back(i);
-                        }
-                        
-                        mesh->mFaces.push_back(new Face(vc));
-                        
-                        // NOTE: should rather be written into trafo of mesh instance
-                        ApplyTransformations(mTransformations, mesh);
-
-                        mesh->Preprocess();
-                        // make an instance of this mesh
-                        MeshInstance *mi = new MeshInstance(mesh);
-                        mCurrentNode->mGeometry.push_back(mi);
-
-                }*/
-
                 //if (mCurrentMesh->mFaces.empty())     cout << "error!" << endl;