Changeset 419 for trunk/VUT/GtpVisibilityPreprocessor/src

Timestamp:

11/17/05 02:26:30 (19 years ago)

Author:

mattausch

Message:

 

Location:

trunk/VUT/GtpVisibilityPreprocessor/src

Files:

• Environment.cpp (modified) (1 diff)
• Preprocessor.cpp (modified) (2 diffs)
• Preprocessor.h (modified) (1 diff)
• RenderSimulator.cpp (modified) (1 diff)
• SamplingPreprocessor.cpp (modified) (2 diffs)
• ViewCell.cpp (modified) (1 diff)
• ViewCell.h (modified) (1 diff)
• ViewCellBsp.h (modified) (1 diff)
• VspKdTree.cpp (modified) (49 diffs)
• VspKdTree.h (modified) (13 diffs)
• X3dExporter.cpp (modified) (2 diffs)
• main.cpp (modified) (2 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/Environment.cpp

@@ -1315 +1315 @@
           "20");
 
-  RegisterOption("ViewCells.maxViewCells",
-          optInt,
-          "-view_cells_max_viewcells=",
-          "0");
-  
   RegisterOption("BspTree.Visualization.samples",
           optInt,

trunk/VUT/GtpVisibilityPreprocessor/src/Preprocessor.cpp

@@ -30 +30 @@
 {
         X3dParser parser;
-        int maxViewCells = 0;
+        
         environment->GetFloatValue("ViewCells.height", parser.mViewCellHeight);
-        environment->GetIntValue("ViewCells.maxViewCells", maxViewCells);
-
-        bool loaded = parser.ParseFile(filename, mViewCells);
-
-        if (maxViewCells > 0)
-        {
-                while (mViewCells.size() > maxViewCells)
-                {
-                        ViewCell *vc = mViewCells.back();
-                        DEL_PTR(vc);
-                        mViewCells.pop_back();
-                }
-        }
-        return loaded;
+        
+        return parser.ParseFile(filename, mViewCells);
 }
 
@@ -121 +109 @@
 }
 
-bool
-Preprocessor::GenerateViewCells()
-{
-        // TODO
-        // HACK: derive view cells from the scene objects
-        ObjectContainer objects;
-
-        int maxViewCells = 0;
-        environment->GetIntValue("ViewCells.maxViewCells", maxViewCells);
-
-        mSceneGraph->CollectObjects(&objects);
-        ViewCell::DeriveViewCells(objects, mViewCells, maxViewCells);
-
-        return true;
-}
-
 int
-SplitFilenames(const string str,
-                                                         vector<string> &filenames)
+SplitFilenames(const string str, vector<string> &filenames)
 {
         int pos = 0;

trunk/VUT/GtpVisibilityPreprocessor/src/Preprocessor.h

@@ -46 +46 @@
   */
   virtual bool LoadViewCells(const string filename);
-  
-  /** Generate the viewCells automatically. The particular algorithm to be used depends
-      on the environment setting. Initially the generated viewcells will cover the whole
-      bounding volume of the scene. They can be pruned later depending on the results
-      of visibility computations.
-      @return true on successful viewcell generation.
-  */
-  virtual bool GenerateViewCells();
   
   /** Export all preprocessed data in a XML format understandable by the

trunk/VUT/GtpVisibilityPreprocessor/src/RenderSimulator.cpp

@@ -183 +183 @@
     mStat.avgRtWithoutOverhead = renderTime;
         mStat.avgRenderTime = renderTime + loadPvsOverhead;
-        
+        mStat.maxCost /= pCrossVcTotal;
+        mStat.minCost /= pCrossVcTotal;
+
         mStat.Stop();
 

trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.cpp

@@ -573 +573 @@
                         if (exporter)
                         {
-                                exporter->ExportBspLeaves(*mBspTree, 350/*stat.maxPvs*/);
+                                exporter->ExportBspLeaves(*mBspTree, stat.maxPvs);
                                 //exporter->ExportBspViewCellPartition(*mBspTree, 0);
                                 delete exporter;
@@ -609 +609 @@
                         if (exporter)
                         {
-                                exporter->ExportBspViewCellPartition(*mBspTree, 350/*stat.maxPvs*/);
+                                exporter->ExportBspViewCellPartition(*mBspTree, stat.maxPvs);
                                 //exporter->ExportBspViewCellPartition(*mBspTree, 0);
                                 delete exporter;

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCell.cpp

@@ -27 +27 @@
                 return NULL;
         }
+}
+
+const ViewCellPvs &ViewCell::GetPvs() const
+{
+        return mPvs;
 }
 

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCell.h

@@ -23 +23 @@
         */
         ViewCell(Mesh *mesh);
-        /** Returns PvS. 
+        /** Returns Pvs. 
         */
+        const ViewCellPvs &GetPvs() const;
         ViewCellPvs &GetPvs();
 

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.h

@@ -770 +770 @@
 
 public:
-        /// Parses the environment and stores the global BSP tree parameters
+        /** Parses the environment and stores the global BSP tree parameters
+        */
         static void ParseEnvironment();
 

trunk/VUT/GtpVisibilityPreprocessor/src/VspKdTree.cpp

@@ -28 +28 @@
 int VspKdTreeLeaf::mailID = 0;
 int VspKdTree::sTermMaxDepth = 10;
-float VspKdTree::sTermMinSize = 0.1;
+float VspKdTree::sTermMinSize = 0.1f;
 int VspKdTree::sTermMinPvs = 10;
 int VspKdTree::sTermMinRays = 20;
-float VspKdTree::sTermMaxCostRatio = 0.1;
-float VspKdTree::sTermMaxRayContribution = 0.1;
+float VspKdTree::sTermMaxCostRatio = 0.1f;
+float VspKdTree::sTermMaxRayContribution = 0.1f;
 
 
@@ -71 +71 @@
 
 /**************************************************************/
- *                VspKdTreeInterior implementation            *
+/*                VspKdTreeInterior implementation            */
 /**************************************************************/
 
@@ -81 +81 @@
 int VspKdTreeInterior::GetAccessTime()
 {
-        return lastAccessTime;
+        return mLastAccessTime;
 }
 
@@ -101 +101 @@
 int VspKdTreeInterior::Type() const  
 { 
-        return VspKdInterior; 
+        return EInterior; 
 }
   
@@ -112 +112 @@
 void VspKdTreeInterior::Print(ostream &s) const 
 {
-        if (axis == 0)
+        if (mAxis == 0)
                 s << "x ";
         else
-                if (axis == 1)
+                if (mAxis == 1)
                         s << "y ";
                 else
                         s << "z ";
-        s << position << " ";
+        s << mPosition << " ";
 
         mBack->Print(s);
@@ -127 +127 @@
 int VspKdTreeInterior::ComputeRayIntersection(const RayInfo &rayData, float &t) 
 {
-        return rayData.ComputeRayIntersection(axis, position, t);
-}
-
+        return rayData.ComputeRayIntersection(mAxis, mPosition, t);
+}
+
+VspKdTreeNode *VspKdTreeInterior::GetBack() const
+{
+        return mBack;
+}
+
+VspKdTreeNode *VspKdTreeInterior::GetFront() const
+{
+        return mFront;
+}
+
+/**************************************************/
+/*         class VspKdTree implementation         */
+/**************************************************/
+void VspKdTree::ParseEnvironment()
+{
+        environment->GetIntValue("VspKdTree.Termination.maxDepth", sTermMaxDepth);
+        environment->GetIntValue("VspKdTree.Termination.minPvs", sTermMinPvs);
+        environment->GetIntValue("VspKdTree.Termination.minRays", sTermMinRays);
+        environment->GetFloatValue("VspKdTree.Termination.maxRayContribution", sTermMaxRayContribution);
+        environment->GetFloatValue("VspKdTree.Termination.maxCostRatio", sTermMaxCostRatio);
+
+        environment->GetFloatValue("VspKdTree.Termination.minSize", sTermMinSize);
+        sTermMinSize = sqr(sTermMinSize);
+}
 
 // Constructor
 VspKdTree::VspKdTree()
-{
-        environment->GetIntValue("VspKdTree.maxDepth", sTermMaxDepth);
-        environment->GetIntValue("VspKdTree.minPvs", sTermMinPvs);
-        environment->GetIntValue("VspKdTree.minRays", sTermMinRays);
-        environment->GetFloatValue("VspKdTree.maxRayContribution", sTermMaxRayContribution);
-        environment->GetFloatValue("VspKdTree.maxCostRatio", sTermMaxCostRatio);
-
-        environment->GetFloatValue("VspKdTree.minSize", sTermMinSize);
-        termMinSize = sqr(termMinSize);
-          
+{         
         environment->GetFloatValue("VspKdTree.epsilon", epsilon);
         environment->GetFloatValue("VspKdTree.ct_div_ci", ct_div_ci);
@@ -150 +165 @@
   
   
-        float refDirAngle;
         environment->GetIntValue("VspKdTree.accessTimeThreshold", accessTimeThreshold);
         //= 1000;
@@ -174 +188 @@
         }
 
-        environment->GetBoolValue("VspKdTree.randomize", randomize);
-
         mRoot = NULL;
 
@@ -184 +196 @@
 VspKdTree::~VspKdTree()
 {
-        if (mRoot)
-                delete mRoot;
+        DEL_PTR(mRoot);
 }
 
@@ -298 +309 @@
         maxMemory = maxStaticMemory;
 
-        if (root)
-                delete root;
-
-        root = new VspKdTreeLeaf(NULL, rays.size());
+        DEL_PTR(mRoot);
+
+        mRoot = new VspKdTreeLeaf(NULL, (int)rays.size());
 
         // first construct a leaf that will get subdivide
-        VspKdTreeLeaf *leaf = (VspKdTreeLeaf *) root;
+        VspKdTreeLeaf *leaf = dynamic_cast<VspKdTreeLeaf *>(mRoot);
 
         
         mStat.nodes = 1;
         
-        bbox.Initialize();
-        dirBBox.Initialize();
-  
+        mBox.Initialize();
         
         for (VssRayContainer::const_iterator ri = rays.begin(); ri != rays.end(); ++ ri)
@@ -317 +325 @@
                 leaf->AddRay(VspKdTreeNode::RayInfo(*ri));
 
-                bbox.Include((*ri)->GetOrigin());
-                bbox.Include((*ri)->GetTermination());    
-                
-                dirBBox.Include(Vector3((*ri)->GetDirParametrization(0), (*ri)->GetDirParametrization(1), 0));
+                mBox.Include((*ri)->GetOrigin());
+                mBox.Include((*ri)->GetTermination()); 
         }
         
         if (forcedBoundingBox)
-                bbox = *forcedBoundingBox;
-
-        cout<<"Bbox = "<<bbox<<endl;
-        cout<<"Dirr Bbox = "<<dirBBox<<endl;
-
-        mStat.rays = leaf->rays.size();
+                mBox = *forcedBoundingBox;
+
+        cout << "Bbox = " << mBox << endl;
+        
+        mStat.rays = (int)leaf->rays.size();
         leaf->UpdatePvsSize();
         
@@ -335 +340 @@
         
         // Subdivide();
-        root = Subdivide(TraversalData(leaf, bbox, 0));
+        mRoot = Subdivide(TraversalData(leaf, mBox, 0));
 
         if (splitCandidates) 
@@ -390 +395 @@
     
                 
-                VspKdTreeNode *node = SubdivideNode((VspKdTreeLeaf *) data.node,
-                                                                                        data.bbox, backBox,     frontBox);
+                VspKdTreeNode *node = SubdivideNode((VspKdTreeLeaf *) data.mNode,
+                                                                                        data.mBox, backBox,     frontBox);
                 if (result == NULL)
                         result = node;
@@ -400 +405 @@
 
                         // push the children on the stack
-                        tStack.push(TraversalData(interior->back, backBox, data.depth+1));
-                        tStack.push(TraversalData(interior->front, frontBox, data.depth+1));
+                        tStack.push(TraversalData(interior->GetBack(), backBox, data.mDepth + 1));
+                        tStack.push(TraversalData(interior->GetFront(), frontBox, data.mDepth + 1));
                 } 
                 else 
@@ -453 +458 @@
   }
 
-        if (costRatio > termMaxCostRatio) 
+        if (costRatio > sTermMaxCostRatio) 
         {
                 //              cout<<"Too big cost ratio "<<costRatio<<endl;
@@ -496 +501 @@
         Intersectable::NewMail(3);
 
-        if (axis <= VspKdTreeNode::SPLIT_Z) {
-    // this is the main ray classification loop!
+        // this is the main ray classification loop!
     for(VspKdTreeNode::RayInfoContainer::iterator ri = leaf->rays.begin();
                 ri != leaf->rays.end(); ri++)
-                if ((*ri).mRay->IsActive()) 
-                {
-                        // determine the side of this ray with respect to the plane
-                        int side = (*ri).ComputeRayIntersection(axis, position, (*ri).mRay->mT);
-                        //                              (*ri).mRay->mSide = side;
+        {
+                if (!(*ri).mRay->IsActive()) 
+                        continue;
                         
-                        if (side <= 0)
-                                raysBack ++;
+                // determine the side of this ray with respect to the plane
+                int side = (*ri).ComputeRayIntersection(axis, position, (*ri).mRay->mT);
+                //                              (*ri).mRay->mSide = side;
+                        
+                if (side <= 0)
+                        ++ raysBack;
                                 
-                        if (side >= 0)
-                                raysFront++;
+                if (side >= 0)
+                        ++ raysFront;
                                 
-                        AddObject2Pvs((*ri).mRay->mTerminationObject, side, pvsBack, pvsFront);
-                }
+                AddObject2Pvs((*ri).mRay->mTerminationObject, side, pvsBack, pvsFront);
+        }       
+
+        AxisAlignedBox3 box = GetBBox(leaf);
+        
+        float minBox = box.Min(axis);
+        float maxBox = box.Max(axis);
+        float sizeBox = maxBox - minBox;
                 
-                AxisAlignedBox3 box = GetBBox(leaf);
-                
-                float minBox = box.Min(axis);
-                float maxBox = box.Max(axis);
-                float sizeBox = maxBox - minBox;
-                
-                //              float sum = raysBack*(position - minBox) + raysFront*(maxBox - position);
-                float sum = pvsBack*(position - minBox) + pvsFront*(maxBox - position);
-
-                newCost = ct_div_ci + sum/sizeBox;
-        } 
-        else 
-        {
-                // directional split
-                for(VspKdTreeNode::RayInfoContainer::iterator ri = leaf->rays.begin();
-                        ri != leaf->rays.end(); ++ ri)
-                        if ((*ri).mRay->IsActive()) 
-                        {
-                                // determine the side of this ray with respect to the plane
-                                int side;
-                                if ((*ri).mRay->GetDirParametrization(axis - 3) > position)
-                                        side = 1;
-                                else
-                                        side = -1;
-
-                                if (side <= 0)
-                                        raysBack++;
-                                
-                                if (side >= 0)
-                                        raysFront++;
-
-                                //                              (*ri).mRay->mSide = side;
-                                AddObject2Pvs((*ri).mRay->mTerminationObject, side, pvsBack, pvsFront);
-                        }
-        
-                        AxisAlignedBox3 box = GetDirBBox(leaf);
-                
-                        float minBox = box.Min(axis - 3);
-                        float maxBox = box.Max(axis - 3);
-                        float sizeBox = maxBox - minBox;
-                
-                        // float sum = raysBack*(position - minBox) + raysFront*(maxBox - position);
-                        float sum =     pvsBack*(position - minBox) + pvsFront*(maxBox - position);
-                //              float sum = pvsBack + pvsFront;
-                newCost = ct_div_ci + sum/sizeBox;
-        }
-
+        //              float sum = raysBack*(position - minBox) + raysFront*(maxBox - position);
+        float sum = pvsBack*(position - minBox) + pvsFront*(maxBox - position);
+
+        newCost = ct_div_ci + sum/sizeBox;
+        
         //      cout<<axis<<" "<<pvsSize<<" "<<pvsBack<<" "<<pvsFront<<endl;
         //  float oldCost = leaf->rays.size();
-        float oldCost = pvsSize;
+        float oldCost = (float)pvsSize;
         
         float ratio = newCost / oldCost;
@@ -587 +557 @@
         
         AxisAlignedBox3 sBox = GetBBox(leaf);
-        AxisAlignedBox3 dBox = GetDirBBox(leaf);
 
         // int sAxis = box.Size().DrivingAxis();
         int sAxis = sBox.Size().DrivingAxis();
-        int dAxis = dBox.Size().DrivingAxis() + 3;
-
+        
         bool onlyDrivingAxis = true; 
 
         for (axis = 0; axis < 6; ++ axis) 
         {
-                if (!onlyDrivingAxis || axis == sAxis || axis == dAxis) 
-                {
-                        if (axis < 3)
-                                nPosition[axis] = (sBox.Min()[axis] + sBox.Max()[axis])*0.5f;
-                        else
-                                nPosition[axis] = (dBox.Min()[axis-3] + dBox.Max()[axis-3])*0.5f;
-                        
+                if (!onlyDrivingAxis || axis == sAxis) 
+                {
+                        nPosition[axis] = (sBox.Min()[axis] + sBox.Max()[axis])*0.5f;
+                                                
                         nCostRatio[axis] = EvalCostRatio(leaf,
                                                                                          axis,
@@ -651 +616 @@
         // C = ct_div_ci  + (ql*rl + qr*rr)/queries
         
-        int rl=0, rr = leaf->rays.size();
+        int rl=0, rr = (int)leaf->rays.size();
         int pl=0, pr = leaf->GetPvsSize();
         float minBox = box.Min(axis);
@@ -657 +622 @@
         float sizeBox = maxBox - minBox;
         
-        float minBand = minBox + 0.1*(maxBox - minBox);
-        float maxBand = minBox + 0.9*(maxBox - minBox);
+        float minBand = minBox + 0.1f*(maxBox - minBox);
+        float maxBand = minBox + 0.9f*(maxBox - minBox);
         
         float sum = rr*sizeBox;
@@ -743 +708 @@
         }
 
-        float oldCost = leaf->GetPvsSize();
+        float oldCost = (float)leaf->GetPvsSize();
         float newCost = ct_div_ci + minSum / sizeBox;
         float ratio = newCost / oldCost;
@@ -789 +754 @@
 {
         // the node became a leaf -> evaluate stats for leafs
-        VspKdTreeLeaf *leaf = (VspKdTreeLeaf *)data.node;
-
-        if (data.depth >= termMaxDepth)
+        VspKdTreeLeaf *leaf = dynamic_cast<VspKdTreeLeaf *>(data.mNode);
+
+        if (data.mDepth >= sTermMaxDepth)
                 ++ mStat.maxDepthNodes;
   
         //  if ( (int)(leaf->rays.size()) < termMinCost)
         //    stat.minCostNodes++;
-        if (leaf->GetPvsSize() < termMinPvs)
+        if (leaf->GetPvsSize() < sTermMinPvs)
                 ++ mStat.minPvsNodes;
 
-        if (leaf->GetPvsSize() < termMinRays)
+        if (leaf->GetPvsSize() < sTermMinRays)
                 ++ mStat.minRaysNodes;
 
-        if (0 && leaf->GetAvgRayContribution() > termMaxRayContribution)
+        if (0 && leaf->GetAvgRayContribution() > sTermMaxRayContribution)
                 ++ mStat.maxRayContribNodes;
         
-        if (SqrMagnitude(data.bbox.Size()) <= termMinSize) 
+        if (SqrMagnitude(data.mBox.Size()) <= sTermMinSize) 
                 ++ mStat.minSizeNodes;
 
@@ -819 +784 @@
                                                                                 AxisAlignedBox3 &frontBBox)
 {
-        if ( (leaf->GetPvsSize() < termMinPvs) || (leaf->rays.size() < termMinRays) ||
+        if ( (leaf->GetPvsSize() < sTermMinPvs) || (leaf->rays.size() < sTermMinRays) ||
         // (leaf->GetAvgRayContribution() > termMaxRayContribution ) ||
-       (leaf->depth >= termMaxDepth) || SqrMagnitude(box.Size()) <= termMinSize ) 
+       (leaf->mDepth >= sTermMaxDepth) || SqrMagnitude(box.Size()) <= sTermMinSize ) 
         {
 
 #if 0
-                if (leaf->depth >= termMaxDepth) {
-                        cout<<"Warning: max depth reached depth="<<(int)leaf->depth<<" rays="<<leaf->rays.size()<<endl;
+                if (leaf->mDepth >= termMaxDepth) {
+                        cout<<"Warning: max depth reached depth="<<(int)leaf->mDepth<<" rays="<<leaf->rays.size()<<endl;
                         cout<<"Bbox: "<<GetBBox(leaf)<<" dirbbox:"<<GetDirBBox(leaf)<<endl;
                 }
@@ -856 +821 @@
 
         // add the new nodes to the tree
-        VspKdTreeInterior *node = new VspKdTreeInterior(leaf->parent);
-
-        node->axis = axis;
-        node->position = position;
-        node->bbox = box;
-        node->dirBBox = GetDirBBox(leaf);
-  
+        VspKdTreeInterior *node = new VspKdTreeInterior(leaf->mParent);
+
+        node->mAxis = axis;
+        node->mPosition = position;
+        node->mBox = box;
+          
         backBBox = box;
         frontBBox = box;
@@ -872 +836 @@
 
         // replace a link from node's parent
-        if (leaf->parent)
-                leaf->parent->ReplaceChildLink(leaf, node);
+        if (leaf->mParent)
+                leaf->mParent->ReplaceChildLink(leaf, node);
         // and setup child links
         node->SetupChildLinks(back, front);
@@ -967 +931 @@
         int released;
 
-        tstack.push(root);
+        tstack.push(mRoot);
 
         while (!tstack.empty()) 
@@ -976 +940 @@
                 if (!node->IsLeaf()) 
                 {
-                        VspKdTreeInterior *in = (VspKdTreeInterior *)node;
+                        VspKdTreeInterior *in = dynamic_cast<VspKdTreeInterior *>(node);
                         // cout<<"depth="<<(int)in->depth<<" time="<<in->lastAccessTime<<endl;
-                        if (in->depth >= minCollapseDepth && in->lastAccessTime <= maxAccessTime) 
+                        if (in->mDepth >= minCollapseDepth && in->mLastAccessTime <= maxAccessTime) 
                         {
                                 released = CollapseSubtree(node, time);
                                 break;
                         }
-                        if (in->back->GetAccessTime() <  in->front->GetAccessTime()) 
+                        if (in->GetBack()->GetAccessTime() <  in->GetFront()->GetAccessTime()) 
                         {
-                                tstack.push(in->front);
-                                tstack.push(in->back);
+                                tstack.push(in->GetFront());
+                                tstack.push(in->GetBack());
                         } 
                         else 
                         {
-                                tstack.push(in->back);
-                                tstack.push(in->front);
+                                tstack.push(in->GetBack());
+                                tstack.push(in->GetFront());
                         }
                 }
@@ -1021 +985 @@
         // check if we should perform a dynamic subdivision of the leaf
         if (// leaf->rays.size() > (unsigned)termMinCost &&
-                (leaf->GetPvsSize() >= termMinPvs) && 
+                (leaf->GetPvsSize() >= sTermMinPvs) && 
                 (SqrMagnitude(leafBBox.Size()) > sizeThreshold) )
         {
@@ -1078 +1042 @@
         stack<RayTraversalData> tstack;
 
-        tstack.push(RayTraversalData(root, VspKdTreeNode::RayInfo(ray)));
+        tstack.push(RayTraversalData(mRoot, VspKdTreeNode::RayInfo(ray)));
   
         RayTraversalData data;
@@ -1088 +1052 @@
                 tstack.pop();
 
-                if (!data.node->IsLeaf()) 
+                if (!data.mNode->IsLeaf()) 
                 {
                         // split the set of rays in two groups intersecting the
@@ -1099 +1063 @@
                         // remove the ray from the leaf
                         // find the ray in the leaf and swap it with the last ray...
-                        VspKdTreeLeaf *leaf = (VspKdTreeLeaf *)data.node;
+                        VspKdTreeLeaf *leaf = (VspKdTreeLeaf *)data.mNode;
       
                         if (!leaf->Mailed()) 
@@ -1168 +1132 @@
         stack<RayTraversalData> tstack;
   
-        tstack.push(RayTraversalData(root, VspKdTreeNode::RayInfo(ray)));
+        tstack.push(RayTraversalData(mRoot, VspKdTreeNode::RayInfo(ray)));
   
         RayTraversalData data;
@@ -1177 +1141 @@
                 tstack.pop();
 
-                if (!data.node->IsLeaf()) 
+                if (!data.mNode->IsLeaf()) 
                 {
                         TraverseInternalNode(data, tstack);
@@ -1185 +1149 @@
                         // remove the ray from the leaf
                         // find the ray in the leaf and swap it with the last ray...
-                        VspKdTreeLeaf *leaf = (VspKdTreeLeaf *)data.node;
-                        leaf->AddRay(data.rayData);
+                        VspKdTreeLeaf *leaf = (VspKdTreeLeaf *)data.mNode;
+                        leaf->AddRay(data.mRayData);
                         ++ mStat.addedRayRefs;
                 }
@@ -1195 +1159 @@
                                                                          stack<RayTraversalData> &tstack)
 {
-        VspKdTreeInterior *in =  (VspKdTreeInterior *) data.node;
-  
-        if (in->axis <= VspKdTreeNode::SPLIT_Z) 
+        VspKdTreeInterior *in =  (VspKdTreeInterior *) data.mNode;
+  
+        if (in->mAxis <= VspKdTreeNode::SPLIT_Z) 
         {
             // determine the side of this ray with respect to the plane
-                int side = in->ComputeRayIntersection(data.rayData, data.rayData.mRay->mT);
+                int side = in->ComputeRayIntersection(data.mRayData, data.mRayData.mRay->mT);
     
       if (side == 0) 
           {
-                if (data.rayData.mRay->HasPosDir(in->axis)) 
-                {
-                        tstack.push(RayTraversalData(in->back, 
-                                                VspKdTreeNode::RayInfo(data.rayData.mRay, data.rayData.mMinT, 
-                                                                                           data.rayData.mRay->mT)));
+                if (data.mRayData.mRay->HasPosDir(in->mAxis)) 
+                {
+                        tstack.push(RayTraversalData(in->GetBack(), 
+                                                VspKdTreeNode::RayInfo(data.mRayData.mRay, data.mRayData.mMinT, 
+                                                                                           data.mRayData.mRay->mT)));
                                 
-                        tstack.push(RayTraversalData(in->front,
-                                                VspKdTreeNode::RayInfo(data.rayData.mRay, data.rayData.mRay->mT, 
-                                                                                           data.rayData.mMaxT)));
+                        tstack.push(RayTraversalData(in->GetFront(),
+                                                VspKdTreeNode::RayInfo(data.mRayData.mRay, data.mRayData.mRay->mT, 
+                                                                                           data.mRayData.mMaxT)));
         
                 } 
                 else 
                 {
-                        tstack.push(RayTraversalData(in->back,
-                                                                                 VspKdTreeNode::RayInfo(data.rayData.mRay,
-                                                                                                                                data.rayData.mRay->mT,
-                                                                                                                                data.rayData.mMaxT)));
-                        tstack.push(RayTraversalData(in->front,
-                                                                                 VspKdTreeNode::RayInfo(data.rayData.mRay,
-                                                                                                                                data.rayData.mMinT,
-                                                                                                                                data.rayData.mRay->mT)));
+                        tstack.push(RayTraversalData(in->GetBack(),
+                                                                                 VspKdTreeNode::RayInfo(data.mRayData.mRay,
+                                                                                                                                data.mRayData.mRay->mT,
+                                                                                                                                data.mRayData.mMaxT)));
+                        tstack.push(RayTraversalData(in->GetFront(),
+                                                                                 VspKdTreeNode::RayInfo(data.mRayData.mRay,
+                                                                                                                                data.mRayData.mMinT,
+                                                                                                                                data.mRayData.mRay->mT)));
                 }
           } 
           else
           if (side == 1)
-                          tstack.push(RayTraversalData(in->front, data.rayData));
+                          tstack.push(RayTraversalData(in->GetFront(), data.mRayData));
                   else
-                          tstack.push(RayTraversalData(in->back, data.rayData));
+                          tstack.push(RayTraversalData(in->GetBack(), data.mRayData));
         } 
         else 
         {
                 // directional split
-                if (data.rayData.mRay->GetDirParametrization(in->axis - 3) > in->position)
-                        tstack.push(RayTraversalData(in->front, data.rayData));
+                if (data.mRayData.mRay->GetDirParametrization(in->mAxis - 3) > in->mPosition)
+                        tstack.push(RayTraversalData(in->GetFront(), data.mRayData));
                 else
-                        tstack.push(RayTraversalData(in->back, data.rayData));
+                        tstack.push(RayTraversalData(in->GetBack(), data.mRayData));
         }
 }
@@ -1290 +1254 @@
                 else 
                 {
-                        tstack.push(((VspKdTreeInterior *)node)->back);
-                        tstack.push(((VspKdTreeInterior *)node)->front);
+                        tstack.push(((VspKdTreeInterior *)node)->GetFront());
+                        tstack.push(((VspKdTreeInterior *)node)->GetBack());
                 }
         }
@@ -1298 +1262 @@
 
         // create a new node that will hold the rays
-        VspKdTreeLeaf *newLeaf = new VspKdTreeLeaf(sroot->parent, rayCount);
-        
-        if (newLeaf->parent)
-                newLeaf->parent->ReplaceChildLink(sroot, newLeaf);
+        VspKdTreeLeaf *newLeaf = new VspKdTreeLeaf(sroot->mParent, rayCount);
+        
+        if (newLeaf->mParent)
+                newLeaf->mParent->ReplaceChildLink(sroot, newLeaf);
 
         tstack.push(sroot);
@@ -1312 +1276 @@
                 if (node->IsLeaf()) 
                 {
-                        VspKdTreeLeaf *leaf = (VspKdTreeLeaf *) node;
+                        VspKdTreeLeaf *leaf = dynamic_cast<VspKdTreeLeaf *>(node);
 
                         for(VspKdTreeNode::RayInfoContainer::iterator ri = leaf->rays.begin();
@@ -1333 +1297 @@
                 else 
                 {
-                        tstack.push(((VspKdTreeInterior *)node)->back);
-                        tstack.push(((VspKdTreeInterior *)node)->front);
+                        VspKdTreeInterior *interior = 
+                                dynamic_cast<VspKdTreeInterior *>(node);
+                        tstack.push(interior->GetBack());
+                        tstack.push(interior->GetFront());
                 }
         }
@@ -1368 +1334 @@
 {
         stack<VspKdTreeNode *> tstack;
-        tstack.push(root);
+        tstack.push(mRoot);
 
         Intersectable::NewMail();
@@ -1407 +1373 @@
                 else 
                 {
-                        VspKdTreeInterior *in = (VspKdTreeInterior *)node;
-        
-                        if (in->axis < 3) 
+                        VspKdTreeInterior *in = dynamic_cast<VspKdTreeInterior *>(node);
+        
+                        if (in->mAxis < 3) 
                         {
-                                if (box.Max(in->axis) >= in->position)
-                                        tstack.push(in->front);
+                                if (box.Max(in->mAxis) >= in->mPosition)
+                                        tstack.push(in->GetFront());
                                 
-                                if (box.Min(in->axis) <= in->position)
-                                        tstack.push(in->back);
+                                if (box.Min(in->mAxis) <= in->mPosition)
+                                        tstack.push(in->GetBack());
                         } 
                         else 
                         {
                                 // both nodes for directional splits
-                                tstack.push(in->front);
-                                tstack.push(in->back);
+                                tstack.push(in->GetFront());
+                                tstack.push(in->GetBack());
                         }
                 }
@@ -1434 +1400 @@
 {
         stack<VspKdTreeNode *> tstack;
-        tstack.push(root);
+        tstack.push(mRoot);
         
         minRayContribution = 1.0f;
@@ -1462 +1428 @@
                         VspKdTreeInterior *in = (VspKdTreeInterior *)node;
                         // both nodes for directional splits
-                        tstack.push(in->front);
-                        tstack.push(in->back);
-                }
-        }
-        
-        cout<<"sum="<<sumRayContribution<<endl;
-        cout<<"leaves="<<leaves<<endl;
+                        tstack.push(in->GetFront());
+                        tstack.push(in->GetBack());
+                }
+        }
+        
+        cout << "sum=" << sumRayContribution << endl;
+        cout << "leaves=" << leaves << endl;
         avgRayContribution = sumRayContribution/(float)leaves;
 }
@@ -1477 +1443 @@
 {
         stack<VspKdTreeNode *> tstack;
-        tstack.push(root);
+        tstack.push(mRoot);
         
         while (!tstack.empty()) 
@@ -1494 +1460 @@
                         {
                                 Vector3 origin = GetBBox(leaf).GetRandomPoint();
-                                Vector3 dirVector = GetDirBBox(leaf).GetRandomPoint();
+                                /*Vector3 dirVector = GetDirBBox(leaf).GetRandomPoint();
                                 Vector3 direction = Vector3(sin(dirVector.x), sin(dirVector.y), cos(dirVector.x));
                                 //cout<<"dir vector.x="<<dirVector.x<<"direction'.x="<<atan2(direction.x, direction.y)<<endl;
-                                rays.push_back(SimpleRay(origin, direction));
+                                rays.push_back(SimpleRay(origin, direction));*/
                         }
                         
@@ -1503 +1469 @@
                 else 
                 {
-                        VspKdTreeInterior *in = (VspKdTreeInterior *)node;
+                        VspKdTreeInterior *in = 
+                                dynamic_cast<VspKdTreeInterior *>(node);
                         // both nodes for directional splits
-                        tstack.push(in->front);
-                        tstack.push(in->back);
+                        tstack.push(in->GetFront());
+                        tstack.push(in->GetBack());
                 }
         }
@@ -1517 +1484 @@
 {
         stack<VspKdTreeNode *> tstack;
-        tstack.push(root);
+        tstack.push(mRoot);
 
         int sumPvs = 0;
@@ -1539 +1506 @@
                         VspKdTreeInterior *in = (VspKdTreeInterior *)node;
                         // both nodes for directional splits
-                        tstack.push(in->front);
-                        tstack.push(in->back);
+                        tstack.push(in->GetFront());
+                        tstack.push(in->GetBack());
                 }
         }
@@ -1552 +1519 @@
 }
 
-AxisAlignedBox3 VspKdTree::GetBBox(const VspKdTreeNode *node) 
-{
-        if (node->parent == NULL)
-                return mBbox;
+AxisAlignedBox3 VspKdTree::GetBBox(VspKdTreeNode *node) const
+{
+        if (node->mParent == NULL)
+                return mBox;
 
         if (!node->IsLeaf())
-                return ((VspKdTreeInterior *)node)->mBbox;
-
-        if (node->parent->axis >= 3)
-                return node->parent->mBbox;
+                return (dynamic_cast<VspKdTreeInterior *>(node))->mBox;
+
+        if (node->mParent->mAxis >= 3)
+                return node->mParent->mBox;
     
-        AxisAlignedBox3 box(node->parent->mBbox);
-        if (node->parent->front == node)
-                box.SetMin(node->parent->axis, node->parent->position);
+        AxisAlignedBox3 box(node->mParent->mBox);
+        if (node->mParent->mFront == node)
+                box.SetMin(node->mParent->mAxis, node->mParent->mPosition);
         else
-                box.SetMax(node->parent->axis, node->parent->position);
-        return mBbox;
+                box.SetMax(node->mParent->mAxis, node->mParent->mPosition);
+
+        return box;
 }
 
@@ -1575 +1543 @@
         return GetPvsSize(mRoot, mBox);
 }
+
+const VspKdStatistics &VspKdTree::GetStatistics() const 
+{
+        return mStat;
+}

trunk/VUT/GtpVisibilityPreprocessor/src/VspKdTree.h

@@ -115 +115 @@
 public:
 
+        friend class VspKdTree;
 #define USE_FIXEDPOINT_T 1
 
@@ -233 +234 @@
   
   // link to the parent
-  VspKdTreeInterior *parent;
+  VspKdTreeInterior *mParent;
 
   enum {SPLIT_X=0, SPLIT_Y, SPLIT_Z, SPLIT_DIRX, SPLIT_DIRY, SPLIT_DIRZ};
   
   // splitting axis
-  char axis;
+  char mAxis;
         
   // depth
-  unsigned char depth;
+  unsigned char mDepth;
   
   //  short depth;
@@ -251 +252 @@
   
   virtual ~VspKdTreeNode() {};
-  virtual int Type() const  = 0;
-  
-
-  bool IsLeaf() const { return axis == -1; }
+  virtual int Type() const = 0;
+  
+
+  bool IsLeaf() const { return mAxis == -1; }
   
   virtual void Print(ostream &s) const = 0;
 
-  virtual int GetAccessTime() {
-    return 0x7FFFFFF;
+  virtual int GetAccessTime() 
+  {
+          return 0x7FFFFFF;
   }
 
@@ -272 +274 @@
 {
 public:
-        
+        friend class VspKdTree;
+
         VspKdTreeInterior(VspKdTreeInterior *p);
                         
         virtual int GetAccessTime();
         
-        virtual int Type();
+        virtual int Type() const;
   
         virtual ~VspKdTreeInterior();
     
         virtual void Print(ostream &s) const;
+
+        inline VspKdTreeNode *GetBack() const;
+        inline VspKdTreeNode *GetFront() const;
 
 protected:
@@ -299 +305 @@
 
         // the bbox of the node
-        AxisAlignedBox3 mBbox;
+        AxisAlignedBox3 mBox;
 
         // data for caching
@@ -310 +316 @@
 // KD-tree node - leaf node
 // --------------------------------------------------------------
-class VspKdTreeLeaf : public VspKdTreeNode
+class VspKdTreeLeaf: public VspKdTreeNode
 {
-private:
-        int mPvsSize;
 public:
+        friend class VspKdTree;
+
         static int mailID;
         int mailbox;
@@ -386 +392 @@
                 return sqr(GetPvsSize()/((float)rays.size() + Limits::Small));
         }
-
+private:
+        int mPvsSize;
 };
 
 // Inline functions
 inline VspKdTreeNode::VspKdTreeNode(VspKdTreeInterior *p):
-parent(p), axis(-1), depth(p ? p->depth + 1 : 0) 
+mParent(p), mAxis(-1), mDepth(p ? p->mDepth + 1 : 0) 
 {}
 
@@ -430 +437 @@
         struct TraversalData
         {  
-                VspKdTreeNode *node;
-                AxisAlignedBox3 bbox;
-                int depth;
-                float priority;
+                VspKdTreeNode *mNode;
+                AxisAlignedBox3 mBox;
+                int mDepth;
+                float mPriority;
         
                 TraversalData() {}
 
                 TraversalData(VspKdTreeNode *n, const float p):
-                node(n), priority(p)
+                mNode(n), mPriority(p)
                 {}
 
                 TraversalData(VspKdTreeNode *n, const AxisAlignedBox3 &b, const int d):
-                node(n), bbox(b), depth(d) {}
+                mNode(n), mBox(b), mDepth(d) {}
     
                 // comparator for the 
@@ -449 +456 @@
                         bool operator()(const TraversalData a, const TraversalData b) 
                         {
-                                return a.priority < b.priority;
+                                return a.mPriority < b.mPriority;
                         }
                 };
@@ -459 +466 @@
                 {
                         // return a.node->queries.size() < b.node->queries.size();
-                        VspKdTreeLeaf *leafa = (VspKdTreeLeaf *) a.node;
-                        VspKdTreeLeaf *leafb = (VspKdTreeLeaf *) b.node;
+                        VspKdTreeLeaf *leafa = (VspKdTreeLeaf *) a.mNode;
+                        VspKdTreeLeaf *leafb = (VspKdTreeLeaf *) b.mNode;
 #if 0
                         return
-                                leafa->rays.size()*a.bbox.GetVolume()
+                                leafa->rays.size()*a.mBox.GetVolume()
                                 <
-                                leafb->rays.size()*b.bbox.GetVolume();
+                                leafb->rays.size()*b.mBox.GetVolume();
 #endif
 #if 1
                         return
-                                leafa->GetPvsSize()*a.bbox.GetVolume()
+                                leafa->GetPvsSize()*a.mBox.GetVolume()
                                 <
-                                leafb->GetPvsSize()*b.bbox.GetVolume();
+                                leafb->GetPvsSize()*b.mBox.GetVolume();
 #endif
 #if 0
@@ -498 +505 @@
   struct RayTraversalData 
   {
-          VspKdTreeNode::RayInfo rayData;
-          VspKdTreeNode *node;
+          VspKdTreeNode::RayInfo mRayData;
+          VspKdTreeNode *mNode;
       
           RayTraversalData() {}
           
           RayTraversalData(VspKdTreeNode *n, const VspKdTreeNode::RayInfo &data):
-          rayData(data), node(n) {}
+          mRayData(data), mNode(n) {}
   };
         
@@ -584 +591 @@
                                                 int &pvsFront);
 
-        AxisAlignedBox3 GetBBox(const VspKdTreeNode *node);     
+        AxisAlignedBox3 GetBBox(VspKdTreeNode *node) const;     
 
         VspKdTreeNode * SubdivideLeaf(VspKdTreeLeaf *leaf,
@@ -620 +627 @@
         int CollapseSubtree(VspKdTreeNode *sroot, const int time);
 
-        const VspKdStatistics &GetStatistics() const {
-                return mStat;
-        }
-        
-        
+        const VspKdStatistics &GetStatistics() const;
+        
+        int ReleaseMemory(const int time);
+
+        /** Parses the environment and stores the global BSP tree parameters
+        */
+        static void ParseEnvironment();
+
         /////////////////////////////
         // Construction parameters
 
         // max depth of the tree
-        int sTermMaxDepth;
+        static int sTermMaxDepth;
 
         // minimal ratio of the volume of the cell and the query volume
-        float sTermMinSize;
+        static float sTermMinSize;
 
         // minimal pvs per node to still get subdivided
-        int sTermMinPvs;
+        static int sTermMinPvs;
 
         // minimal ray number per node to still get subdivided
-        int sTermMinRays;
+        static int sTermMinRays;
         
         // maximal cost ration to subdivide a node
-        float sTermMaxCostRatio;
+        static float sTermMaxCostRatio;
         
         // maximal contribution per ray to subdivide the node
-        float sTermMaxRayContribution;
+        static float sTermMaxRayContribution;
 
 protected:

trunk/VUT/GtpVisibilityPreprocessor/src/X3dExporter.cpp

@@ -585 +585 @@
 bool X3dExporter::ExportVspKdTree(const VspKdTree &tree)
 {
-         if (mExportRayDensity) 
-         {
-                 return ExportKdTreeRayDensity(tree);
-         }
+         /*if (mExportRayDensity) {      
+         return ExportKdTreeRayDensity(tree); }*/
      
          stack<VspKdTreeNode *> tStack;
@@ -626 +624 @@
                  {
                          VspKdTreeInterior *interior = dynamic_cast<VspKdTreeInterior *>(node);
-                         tStack.push(interior->mFront);
-                         tStack.push(interior->mBack);
+                         tStack.push(interior->GetFront());
+                         tStack.push(interior->GetBack());
                  }
          }

trunk/VUT/GtpVisibilityPreprocessor/src/main.cpp

@@ -24 +24 @@
   MeshKdTree::ParseEnvironment();
   BspTree::ParseEnvironment();
+  VspKdTree::ParseEnvironment();
 
   char buff[128];
@@ -66 +67 @@
           if (BspTree::sConstructionMethod == BspTree::FROM_INPUT_VIEW_CELLS)
           {
-                   // view cells input file name
+                  // view cells input file name
                   environment->GetStringValue("ViewCells.filename", buff);
                   string vcFilename(buff);
-
-                  if (vcFilename != "")
-                          p->LoadViewCells(vcFilename);
-                  else
-                          p->GenerateViewCells();
-
-                  Debug << "Viewcells loaded / generated. Number of view cells: " << (int)p->mViewCells.size() << endl;
+                  p->LoadViewCells(vcFilename);
+                  Debug << (int)p->mViewCells.size() << " view cells loaded" << endl;
           }