Changeset 406 for trunk/VUT

Timestamp:

11/11/05 21:28:02 (19 years ago)

Author:

mattausch

Message:

started kd based bottom-up view cells

Location:

trunk/VUT/GtpVisibilityPreprocessor

Files:

• scripts/Preprocessor.vcproj (modified) (3 diffs)
• scripts/default.env (modified) (3 diffs)
• src/Environment.cpp (modified) (2 diffs)
• src/Mesh.h (modified) (1 diff)
• src/Pvs.h (modified) (2 diffs)
• src/Ray.cpp (modified) (1 diff)
• src/Ray.h (modified) (1 diff)
• src/RenderSimulator.cpp (added)
• src/RenderSimulator.h (added)
• src/SamplingPreprocessor.cpp (modified) (5 diffs)
• src/SamplingPreprocessor.h (modified) (1 diff)
• src/ViewCellBsp.cpp (modified) (17 diffs)
• src/ViewCellBsp.h (modified) (1 diff)
• src/ViewCellKd.cpp (added)
• src/ViewCellKd.h (moved) (moved from trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsKd.h) (26 diffs)

trunk/VUT/GtpVisibilityPreprocessor/scripts/Preprocessor.vcproj

@@ -243 +243 @@
                         </File>
                         <File
+                                RelativePath="..\src\RenderSimulator.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\RenderSimulator.h">
+                        </File>
+                        <File
                                 RelativePath="..\src\SamplingPreprocessor.cpp">
                         </File>
@@ -283 +289 @@
                         <File
                                 RelativePath="..\src\ViewCellBsp.h">
+                        </File>
+                        <File
+                                RelativePath="..\src\ViewCellKd.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\ViewCellKd.h">
                         </File>
                         <File
@@ -358 +370 @@
                                 RelativePath="..\include\ViewCell.h">
                         </File>
-                        <File
-                                RelativePath="..\include\ViewCellBsp.h">
-                        </File>
                 </Filter>
         </Files>

trunk/VUT/GtpVisibilityPreprocessor/scripts/default.env

@@ -56 +56 @@
 
 Sampling {
-        totalSamples    300000
+        totalSamples    1000000
         samplesPerPass  3
 }
@@ -126 +126 @@
         #splitPlaneStrategy 130
         
-        splitPlaneStrategy 1024
+        splitPlaneStrategy 1
         
-        maxPolyCandidates 0
-        maxRayCandidates 50
+        maxPolyCandidates 50
+        maxRayCandidates 100
         
         Termination {
                 # autopartition
-                maxRays 300
+                maxRays 200
                 maxPolygons -1
                 maxDepth 40
@@ -161 +161 @@
         }
 }
+
+Simulation {
+        objRenderCost 1.0
+        vcOverhead 0.05
+}

trunk/VUT/GtpVisibilityPreprocessor/src/Environment.cpp

@@ -1177 +1177 @@
   RegisterOption("ViewCells.PostProcessing.minPvsDif",
                  optInt,
-                 "-view_cells_min_pvs_dif",
+                 "-view_cells_post_processing_min_pvs_dif",
                  "10");
-  
+
   RegisterOption("ViewCells.PostProcessing.maxPvs",
                  optInt,
-                 "-view_cells_max_pvs",
+                 "-view_cells_post_processing_max_pvs",
                  "300");
 
   RegisterOption("ViewCells.PostProcessing.minPvs",
                  optString,
-                 "-view_cells_min_pvs",
+                 "-view_cells_post_processing_min_pvs",
                  "10");
 
@@ -1199 +1199 @@
                  "-view_cells_height=",
                  "5.0");
+   
+  RegisterOption("Simulation.objRenderCost",
+                 optFloat,
+                 "-simulation_obj_render_cost",
+                 "1.0");
+
+  RegisterOption("Simulation.vcOverhead",
+                 optFloat,
+                 "-simulation_vc_overhead",
+                 "0.05");
 
   RegisterOption("BspTree.Construction.input",

trunk/VUT/GtpVisibilityPreprocessor/src/Mesh.h

@@ -192 +192 @@
   virtual float IntersectionComplexity() {  return (float)mMesh->mFaces.size(); }
 
-        virtual int NumberOfFaces() const {  return mMesh->mFaces.size(); }
+        virtual int NumberOfFaces() const {  return (int)mMesh->mFaces.size(); }
 
   virtual int Type() const { return MESH_INSTANCE; }

trunk/VUT/GtpVisibilityPreprocessor/src/Pvs.h

@@ -8 +8 @@
 class Ray;
 class Intersectable;
-
+class ViewCellKdNode;
 
 template<typename T>
@@ -142 +142 @@
 
 typedef std::map<KdNode *, PvsData<KdNode *>, LtSample<KdNode *> > KdPvsMap;
+typedef std::map<ViewCellKdNode *, PvsData<ViewCellKdNode *>, LtSample<ViewCellKdNode *> > ViewCellKdPvsMap;
 typedef std::map<Intersectable *, PvsData<Intersectable *>, LtSample<Intersectable *> > ViewCellPvsMap;
 typedef PvsData<Intersectable *> ViewCellPvsData;
 typedef PvsData<KdNode *> KdPvsData;
-//typedef Pvs<KdNode *> KdPvs;
+typedef Pvs<ViewCellKdNode *> ViewCellKdPvs;
 typedef Pvs<Intersectable *> ViewCellPvs;
 

trunk/VUT/GtpVisibilityPreprocessor/src/Ray.cpp

@@ -172 +172 @@
 int
 Ray::ClassifyPlane(const Plane3 &plane, 
-                                                                         const float minT, 
-                                                                         const float maxT) const
-{
-        const Vector3 entp = Extrap(minT);
-        const Vector3 extp = Extrap(maxT);
-  
-        const int entSide = plane.Side(entp);
-        const int extSide = plane.Side(extp);
+                                   const float minT, 
+                                   const float maxT,
+                                   Vector3 &entP,
+                                   Vector3 &extP) const
+{
+        entP = Extrap(minT);
+        extP = Extrap(maxT);
+  
+        const int entSide = plane.Side(entP);
+        const int extSide = plane.Side(extP);
 
         if (entSide < 0)
+        {
+                if (extSide >= 0)
                 {
-                        if (extSide >= 0)
-                                {
-                                        return BACK_FRONT;
-                                }
-                        return BACK;
+                        return BACK_FRONT;
                 }
+                return BACK;
+        }
         else if (entSide > 0)
-                {
-                        if (extSide <= 0)
-                                return FRONT_BACK;
+        {
+                if (extSide <= 0)
+                        return FRONT_BACK;
                         
-                        return FRONT;
-                }
+                return FRONT;
+        }
         else if (entSide == 0)
-                {
-                        if (extSide > 0)
-                                return BACK_FRONT;
-                        else if (extSide < 0)
-                                return FRONT_BACK;
-                }
+        {
+                if (extSide > 0)
+                        return BACK_FRONT;
+                else if (extSide < 0)
+                        return FRONT_BACK;
+        }
         
         return COINCIDENT;

trunk/VUT/GtpVisibilityPreprocessor/src/Ray.h

@@ -214 +214 @@
   /** Classifies ray with respect to the plane.
   */
-  int ClassifyPlane(const Plane3 &plane, const float minT, const float maxT) const;
+  int ClassifyPlane(const Plane3 &plane, 
+                                        const float minT, 
+                                        const float maxT,
+                                        Vector3 &entP,
+                                        Vector3 &extP) const;
 
 private:

trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.cpp

@@ -7 +7 @@
 #include "Polygon3.h"
 #include "ViewCell.h"
+#include "RenderSimulator.h"
 
 SamplingPreprocessor::SamplingPreprocessor(): mPass(0), mSampleRays(NULL)
@@ -16 +17 @@
   environment->GetIntValue("ViewCells.PostProcessing.samples", mPostProcessSamples);
   environment->GetIntValue("BspTree.Visualization.samples", mVisualizationSamples);
+  environment->GetFloatValue("Simulation.objRenderCost", mObjRenderCost);
+  environment->GetFloatValue("Simulation.vcOverhead", mVcOverhead);
 
   mKdPvsDepth = 100;
@@ -540 +543 @@
                 //-- render simulation
                 cout << "\nevaluating render time before merge ... ";
-                Real rt = SimulateRendering();
+                Real rt = BspTreeRenderSimulator(mObjRenderCost, mVcOverhead, mBspTree).SimulateRendering();
                 
                 cout << "avg render time: " << rt * 1e-3 << endl;
@@ -586 +589 @@
                 cout << "\nevaluating render time after merge ... ";
                         
-                rt = SimulateRendering();
+                rt = BspTreeRenderSimulator(mObjRenderCost, mVcOverhead, mBspTree).SimulateRendering();
 
                 cout << "render time: " << rt * 1e-3 << endl;
@@ -1034 +1037 @@
         }
 }
-
-
-Real SamplingPreprocessor::RenderPvs(ViewCell &viewCell, 
-                                                                         const float objRenderTime) const
-{
-        return viewCell.GetPvs().GetSize() * objRenderTime;
-}
-
-Real SamplingPreprocessor::SimulateRendering()
-{
-        Real renderTime = 0;
-
-        // render time for 1 object of PVS
-        const float objRt = 1.0f; 
-         // const overhead for crossing a view cell border
-        const float vcOverhead = 0;//0.01f;
-        
-        // total area of view cells
-        float totalArea = 0;//= mKdTree->GetBox().SurfaceArea();
-
-        ViewCellContainer viewCells;
-
-        mBspTree->CollectViewCells(viewCells);
-
-        ViewCellContainer::const_iterator it, it_end = viewCells.end();
-        
-        for (it = viewCells.begin(); it != it_end; ++ it)
-        {
-                // surface area substitute for probability
-                PolygonContainer cell;
-                float area = 0;
-
-                mBspTree->ConstructGeometry(dynamic_cast<BspViewCell *>(*it), cell);
-
-                area = Polygon3::GetArea(cell);
-                
-                renderTime += area * RenderPvs(*(*it), objRt) + vcOverhead;
-                totalArea += area;
-                CLEAR_CONTAINER(cell);
-        }
-
-        renderTime /= totalArea;
-
-        //Debug << "render time without overhead: " << renderTime * 1e-3 << endl;
-        //renderTime += (float)viewCells.size() * vcOverhead;
-
-        return renderTime;
-}

trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.h

@@ -99 +99 @@
         int PostprocessViewCells(const RayContainer &rays);
 
-        /** Simulated rendering using a simple render heuristics. Used to evaluate the 
-                quality of the view cell partition.
-        */
-        Real SimulateRendering();
-        /** Simulates rendering of the pvs of one view cell, with given rendering time for an object.
-                @param viewCell the view cell holding the Pvs
-                @param objRenderTime estimated render time for one object of the Pvs
-        */
-        Real RenderPvs(ViewCell &viewCell, const float objRenderTime) const;
-
+        // rendering costs for a single object
+        float mObjRenderCost;
+        // rendering overhead when crossing a view cell border
+        float mVcOverhead;
 };
 
-
-
 #endif

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -67 +67 @@
 */
 float BspTree::sBalancedRaysTable[] = {1, -1, 0, 0, 0};
+
+bool BspTree::sPvsUseArea = true;
 
 /****************************************************************/
@@ -1036 +1038 @@
 }
 
-Plane3 BspTree::SelectPlane(BspLeaf *leaf, 
-                                                        BspTraversalData &data)
+Plane3 BspTree::SelectPlane(BspLeaf *leaf, BspTraversalData &data)
 {
         if (data.mPolygons->empty() && data.mRays->empty())
@@ -1071 +1072 @@
         if (sSplitPlaneStrategy & RANDOM_POLYGON)
         {
-                if (!data.mPolygons->empty())
+        if (!data.mPolygons->empty())
                 {
                         Polygon3 *nextPoly = (*data.mPolygons)[Random((int)data.mPolygons->size())];
                         return nextPoly->GetSupportingPlane();
                 }
-                
+                else
+                {
+                        const int candidateIdx = Random((int)data.mRays->size());
+                        BoundedRay *bRay = (*data.mRays)[candidateIdx];
+
+                        Ray *ray = bRay->mRay;
+                                                
+                        const Vector3 minPt = ray->Extrap(bRay->mMinT);
+                        const Vector3 maxPt = ray->Extrap(bRay->mMaxT);
+
+                        const Vector3 pt = (maxPt + minPt) * 0.5;
+
+                        const Vector3 normal = ray->GetDir();
+                        
+                        return Plane3(normal, pt);
+                }
+
                 return Plane3();
         }
@@ -1084 +1101 @@
 }
 
-Plane3 BspTree::SelectPlaneHeuristics(BspLeaf *leaf,
-                                                                          BspTraversalData &data)
+Plane3 BspTree::SelectPlaneHeuristics(BspLeaf *leaf, BspTraversalData &data)
 {
         float lowestCost = MAX_FLOAT;
         Plane3 bestPlane;
-        
+        Plane3 plane;
+
         int limit = Min((int)data.mPolygons->size(), sMaxPolyCandidates);
         
@@ -1096 +1113 @@
         for (int i = 0; i < limit; ++ i)
         {
-                Debug << i << " ";
                 candidateIdx = GetNextCandidateIdx(candidateIdx, *data.mPolygons);
                 
@@ -1116 +1132 @@
         const BoundedRayContainer *rays = data.mRays;
 
-        for (int i = 0; i < sMaxRayCandidates; ++ i)
-        {
-                Plane3 plane;
-
-                if (0)
-                {
-                        Vector3 pt[3];
-                        int idx[3];
-                        int cmaxT = 0;
-                        int cminT = 0;
-                        bool chooseMin = false;
-
-                        for (int j = 0; j < 3; j ++)
-                        {
-                                idx[j] = Random((int)rays->size() * 2);
-                                
-                                if (idx[j] >= (int)rays->size())
-                                {
-                                        idx[j] -= (int)rays->size();
-                                        
-                                        chooseMin = (cminT < 2);
-                                }
-                                else
-                                        chooseMin = (cmaxT < 2);
-
-                                BoundedRay *bRay = (*rays)[idx[j]];
-                                pt[j] = chooseMin ? bRay->mRay->Extrap(bRay->mMinT) : bRay->mRay->Extrap(bRay->mMaxT);
-                        }       
+        for (int i = 0; i < sMaxRayCandidates / 2; ++ i)
+        {
+                candidateIdx = Random((int)rays->size());
+                BoundedRay *bRay = (*rays)[candidateIdx];
+
+                Ray *ray = bRay->mRay;
+                                                
+                const Vector3 minPt = ray->Extrap(bRay->mMinT);
+                const Vector3 maxPt = ray->Extrap(bRay->mMaxT);
+
+                const Vector3 pt = (maxPt + minPt) * 0.5;
+
+                const Vector3 normal = ray->GetDir();
                         
-                        plane = Plane3(pt[0], pt[1], pt[2]);
-                }
-                else
-                {
-                        candidateIdx = Random((int)rays->size());
-                        BoundedRay *bRay = (*rays)[candidateIdx];
-
-                        Ray *ray = bRay->mRay;
-                                                
-                        const Vector3 minPt = ray->Extrap(bRay->mMinT);
-                        const Vector3 maxPt = ray->Extrap(bRay->mMaxT);
-
-                        const Vector3 pt = (maxPt + minPt) * 0.5;
-
-                        const Vector3 normal = ray->GetDir();
-                        
-                        plane = Plane3(normal, pt);
-                }
-                
+                plane = Plane3(normal, pt);
+        
                 const float candidateCost = SplitPlaneCost(plane, data);
 
                 if (candidateCost < lowestCost)
                 {
-                        Debug << "choose ray plane: " << candidateCost << endl;
                         bestPlane = plane;
                         
@@ -1175 +1158 @@
         }
 
-        Debug << "Plane lowest cost: " << lowestCost << endl;
+        Debug << "lowest: " << lowestCost << endl;
+                
+        for (int i = 0; i < sMaxRayCandidates / 2; ++ i)
+        {
+                Vector3 pt[3];
+                int idx[3];
+                int cmaxT = 0;
+                int cminT = 0;
+                bool chooseMin = false;
+
+                for (int j = 0; j < 3; j ++)
+                {
+                        idx[j] = Random((int)rays->size() * 2);
+                                
+                        if (idx[j] >= (int)rays->size())
+                        {
+                                idx[j] -= (int)rays->size();
+                                
+                                chooseMin = (cminT < 2);
+                        }
+                        else
+                                chooseMin = (cmaxT < 2);
+
+                        BoundedRay *bRay = (*rays)[idx[j]];
+                        pt[j] = chooseMin ? bRay->mRay->Extrap(bRay->mMinT) : bRay->mRay->Extrap(bRay->mMaxT);
+                }       
+                        
+                plane = Plane3(pt[0], pt[1], pt[2]);
+
+                const float candidateCost = SplitPlaneCost(plane, data);
+
+                if (candidateCost < lowestCost)
+                {
+                        Debug << "choose ray plane 2: " << candidateCost << endl;
+                        bestPlane = plane;
+                        
+                        lowestCost = candidateCost;
+                }
+        }       
+
+        Debug << "plane lowest cost: " << lowestCost << endl;
         return bestPlane;
 }
@@ -1358 +1381 @@
                 Intersectable::NewMail(); frontAndBackId = ViewCell::sMailId;
 
-                if (1) // use front and back cell areas to approximate volume
+                if (sPvsUseArea) // use front and back cell areas to approximate volume
                 {       
                         // construct child geometry with regard to the candidate split plane
@@ -1371 +1394 @@
                         pOverall = area;
                 }
-                else
-                {
-                        pOverall = (float)rays.size();
-                }
         }
                         
@@ -1385 +1404 @@
                 const float maxT = (*rit)->mMaxT;
 
+                Vector3 entP, extP;
+
                 const int cf = 
-                        ray->ClassifyPlane(candidatePlane, minT, maxT);
+                        ray->ClassifyPlane(candidatePlane, minT, maxT, entP, extP);
 
                 if (sSplitPlaneStrategy & LEAST_RAY_SPLITS)
@@ -1416 +1437 @@
                         }
 
-                        // use #rays to approximate volume
-                        if (0)
+                        if (!sPvsUseArea) // use front and back cell areas to approximate volume
                         {
-                                if ((cf == Ray::BACK) || (cf == Ray::FRONT_BACK) || (cf == Ray::BACK_FRONT))
-                                        ++ pFront;
-                                if ((cf == Ray::FRONT) || (cf == Ray::FRONT_BACK) || (cf == Ray::BACK_FRONT))
-                                        ++ pBack;
+                                float len = Distance(entP, extP);
+                                pOverall += len;
+
+                                // use length of rays to approximate volume
+                                switch (cf)
+                                {
+                                        case Ray::COINCIDENT:
+                                                pBack += len;
+                                                pFront += len;                                          
+                                                break;
+                                        case Ray::BACK:
+                                                pBack += len;
+                                                break;
+                                        case Ray::FRONT:
+                                                pFront += len;
+                                                break;
+                                        case Ray::FRONT_BACK:
+                                                {
+                                                        // find intersection of ray segment with plane
+                                                        const Vector3 extp = ray->Extrap(maxT);
+                                                        const float t = candidatePlane.FindT(ray->GetLoc(), extp);
+                                        
+                                                        const float newT = t * maxT;
+                                                        float newLen = Distance(ray->Extrap(newT), extp);
+
+                                                        pFront += len - newLen;
+                                                        pBack += newLen;
+                                                }
+                                                break;
+                                        case Ray::BACK_FRONT:
+                                                {
+                                                        // find intersection of ray segment with plane
+                                                        const Vector3 extp = ray->Extrap(maxT);
+                                                        const float t = candidatePlane.FindT(ray->GetLoc(), extp);
+                                        
+                                                        const float newT = t * maxT;
+                                                        float newLen = Distance(ray->Extrap(newT), extp);
+
+                                                        pFront += len;
+                                                        pBack += len - newLen;
+                                                }
+                                                break;
+                                        default:
+                                                Debug << "Should not come here" << endl;
+                                                break;
+                                }
                         }
                 }
@@ -1443 +1505 @@
         }
 
-if ((val < 0.00001) || (frontPvs + backPvs < pvs))
-{
-        // create three unique ids for pvs heuristics
-        Intersectable::NewMail(); backId = ViewCell::sMailId;
-        Intersectable::NewMail(); frontId = ViewCell::sMailId;
-        Intersectable::NewMail(); frontAndBackId = ViewCell::sMailId;
-
-
-        BoundedRayContainer::const_iterator rit, rit_end = rays.end();
-
-        int fpvs = 0; int bpvs = 0;
-        for (rit = rays.begin(); rit != rays.end(); ++ rit)
-        {
-                Ray *ray = (*rit)->mRay;
-                const float minT = (*rit)->mMinT;
-                const float maxT = (*rit)->mMaxT;
-
-                const int cf = 
-                        ray->ClassifyPlane(candidatePlane, minT, maxT);
-
-                Debug << "classification: " << cf << endl;
-                if (!ray->intersections.empty())
-                {
-                        // in case the ray intersects an objcrs
-                        // assure that we only count a object 
-                        // once for the front and once for the back side of the plane
-                        IncPvs(*ray->intersections[0].mObject, fpvs, bpvs, 
-                                   cf, frontId, backId, frontAndBackId);
-                }
-                // the source object in the origin of the ray
-                if (ray->sourceObject.mObject)
-                {
-                        IncPvs(*ray->sourceObject.mObject, fpvs, bpvs, 
-                                   cf, frontId, backId, frontAndBackId);
-                }
-
-        }
-
+        if (0)
         Debug << "totalpvs: " << pvs << " ptotal: " << pOverall
                   << " frontpvs: " << frontPvs << " pFront: " << pFront 
                   << " backpvs: " << backPvs << " pBack: " << pBack 
-                  << " val " << val << " new size: " << ComputePvsSize(rays)
-                  << " fp " << fpvs << " bp " << bpvs << endl << endl;
-
-}
+                  << " val " << val << " new size: " << ComputePvsSize(rays)<< endl << endl;
+
         return val;
 }
@@ -2016 +2039 @@
                 BoundedRay *bRay = rays.back();
                 Ray *ray = bRay->mRay;
+                float minT = bRay->mMinT;
+                float maxT = bRay->mMaxT;
+
                 rays.pop_back();
+        
+                Vector3 entP, extP;
+
+                const int cf = 
+                        ray->ClassifyPlane(plane, minT, maxT, entP, extP);
                 
-                const int cf = 
-                        ray->ClassifyPlane(plane, bRay->mMinT, bRay->mMaxT);
-                
+                // set id to ray classification
                 ray->SetId(cf);
 
                 switch (cf)
                 {
-                case Ray::COINCIDENT:
+                case Ray::COINCIDENT: // TODO: should really discard ray?
                         //frontRays.push_back(bRay);
                         DEL_PTR(bRay);
@@ -2038 +2067 @@
                         {
                                 // find intersection of ray segment with plane
-                                const Vector3 extp = ray->Extrap(bRay->mMaxT);
-                                const float t = plane.FindT(ray->GetLoc(), extp);
+                                const float t = plane.FindT(ray->GetLoc(), extP);
                                 
-                                const float newT = t * bRay->mMaxT;
-
-                                frontRays.push_back(new BoundedRay(ray, bRay->mMinT, newT));
-                                backRays.push_back(new BoundedRay(ray, newT, bRay->mMaxT));
+                                const float newT = t * maxT;
+
+                                frontRays.push_back(new BoundedRay(ray, minT, newT));
+                                backRays.push_back(new BoundedRay(ray, newT, maxT));
 
                                 DEL_PTR(bRay);
@@ -2054 +2082 @@
                         {
                                 // find intersection of ray segment with plane
-                                const Vector3 extp = ray->Extrap(bRay->mMaxT);
-                                const float t = plane.FindT(ray->GetLoc(), extp);
+                                const float t = plane.FindT(ray->GetLoc(), extP);
                                 const float newT = t * bRay->mMaxT;
 
@@ -2411 +2438 @@
         for (int i = 0; i < (int)mPolys.size(); ++ i)
         {
-                const int cf = mPolys[i]->ClassifyPlane(splitPlane, 0.00001);
+                const int cf = mPolys[i]->ClassifyPlane(splitPlane, 0.00001f);
                         
                 // split new polygon with all previous planes
@@ -2473 +2500 @@
 
                 const int cf = 
-                        planePoly->ClassifyPlane(plane, 0.00001);
+                        planePoly->ClassifyPlane(plane, 0.00001f);
                         
                 // split new polygon with all previous planes

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.h

@@ -814 +814 @@
         static int sMinPvs;
         static int sMaxPvs;
+        static bool sPvsUseArea;
 
 private:

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellKd.h

@@ -1 @@
-#ifndef _KdTree_H__
-#define _KdTree_H__
+#ifndef _ViewCellKdTree_H__
+#define _ViewCellKdTree_H__
 
 #include <functional>
@@ -11 +11 @@
 
   
-class KdNode;
-class KdLeaf;
-class KdInterior;
+class ViewCellKdNode;
+class ViewCellKdLeaf;
+class ViewCellKdInterior;
 class Intersectable;
 
@@ -20 +20 @@
 // Static statistics for kd-tree search
 // --------------------------------------------------------------
-class KdTreeStatistics 
+class ViewCellKdTreeStatistics 
 {
 public:  
@@ -51 +51 @@
   
   // Constructor
-  KdTreeStatistics() {
+  ViewCellKdTreeStatistics() {
     Reset();
   }
@@ -75 +75 @@
   Print(ostream &app) const;
 
-  friend ostream &operator<<(ostream &s, const KdTreeStatistics &stat) {
+  friend ostream &operator<<(ostream &s, const ViewCellKdTreeStatistics &stat) {
     stat.Print(s);
     return s;
@@ -83 +83 @@
 
   
-class KdInterior;
+class ViewCellKdInterior;
 /** Abstract class for kd-tree node */
-class KdNode {
+class ViewCellKdNode {
 public:
   static int mailID;
@@ -95 +95 @@
 
 
-  KdNode(KdInterior *parent);
+  ViewCellKdNode(ViewCellKdInterior *parent);
 
   /** Determines whether this node is a leaf or interior node
@@ -111 +111 @@
   /** Parent of the node - the parent is a little overhead for maintanance of the tree,
       but allows various optimizations of tree traversal algorithms */
-  KdInterior *mParent;
+  ViewCellKdInterior *mParent;
   int mDepth;
 };
 
 /** Implementation of the kd-tree interior node */
-class KdInterior : public KdNode {
+class ViewCellKdInterior : public ViewCellKdNode {
 
 public:
     
-  KdInterior(KdInterior *parent):KdNode(parent), mBack(NULL), mFront(NULL) {}
-
-  /** \sa KdNode::IsLeaf() */
+  ViewCellKdInterior(ViewCellKdInterior *parent):ViewCellKdNode(parent), mBack(NULL), mFront(NULL) {}
+
+  /** \sa ViewCellKdNode::IsLeaf() */
   virtual bool IsLeaf() const { return false; }
 
@@ -133 +133 @@
 
   /** back node */
-  KdNode *mBack;
+  ViewCellKdNode *mBack;
   /** front node */
-  KdNode *mFront;
-
-  void SetupChildLinks(KdNode *b, KdNode *f) {
+  ViewCellKdNode *mFront;
+
+  void SetupChildLinks(ViewCellKdNode *b, ViewCellKdNode *f) {
     mBack = b;
     mFront = f;
@@ -143 +143 @@
   }
   
-  void ReplaceChildLink(KdNode *oldChild, KdNode *newChild) {
+  void ReplaceChildLink(ViewCellKdNode *oldChild, ViewCellKdNode *newChild) {
     if (mBack == oldChild)
       mBack = newChild;
@@ -155 +155 @@
   
 /** Implementation of the kd-tree leaf node */
-class KdLeaf : public KdNode {
+class ViewCellKdLeaf : public ViewCellKdNode {
 public:
-  KdLeaf(KdInterior *parent, const int objects):KdNode(parent) {
+  ViewCellKdLeaf(ViewCellKdInterior *parent, const int objects):ViewCellKdNode(parent) {
     mObjects.reserve(objects);
   }
@@ -176 +176 @@
   }
 
-  /** \sa KdNode::IsLeaf() */
+  /** \sa ViewCellKdNode::IsLeaf() */
   virtual bool IsLeaf() const { return true; }
   
@@ -191 +191 @@
   PassingRaySet mPassingRays;
         
-  /** PVS consisting of visible KdTree nodes */
-  KdPvs mKdPvs;
+  /** PVS consisting of visible ViewCellKd nodes */
+  ViewCellKdPvs mKdPvs;
         
         /** PVS consisting of visible objects */
@@ -200 +200 @@
   
 
-/** KdTree for indexing scene entities - occluders/occludees/viewcells */
-class KdTree {
+/** ViewCellKd for indexing scene entities - occluders/occludees/viewcells */
+class ViewCellKd {
 
 protected:
   struct TraversalData
   {  
-    KdNode *mNode;
+    ViewCellKdNode *mNode;
     AxisAlignedBox3 mBox;
     int mDepth;
@@ -213 +213 @@
     TraversalData() {}
 
-    TraversalData(KdNode *n, const float p):
+    TraversalData(ViewCellKdNode *n, const float p):
       mNode(n), mPriority(p)
     {}
     
-    TraversalData(KdNode *n,
+    TraversalData(ViewCellKdNode *n,
                    const AxisAlignedBox3 &b,
                    const int d):
@@ -225 +225 @@
     bool operator<(
                    const TraversalData &b) const {
-      KdLeaf *leafa = (KdLeaf *) mNode;
-      KdLeaf *leafb = (KdLeaf *) b.mNode;
+      ViewCellKdLeaf *leafa = (ViewCellKdLeaf *) mNode;
+      ViewCellKdLeaf *leafb = (ViewCellKdLeaf *) b.mNode;
       return 
         leafa->mObjects.size()*mBox.SurfaceArea()
@@ -254 +254 @@
         SPLIT_SAH};
   
-  KdTree();
+  ViewCellKd();
   
     
@@ -274 +274 @@
       were already met
   */
-  virtual KdNode *Subdivide(const TraversalData &tdata);
+  virtual ViewCellKdNode *Subdivide(const TraversalData &tdata);
 
   /** Get the root of the tree */
-  KdNode *GetRoot() const {
+  ViewCellKdNode *GetRoot() const {
     return mRoot;
   }
@@ -289 +289 @@
           );
 
-  const KdTreeStatistics &GetStatistics() const {
+  const ViewCellKdTreeStatistics &GetStatistics() const {
     return mStat;
   }
 
   void
-  CollectObjects(KdNode *n, ObjectContainer &objects);
+  CollectObjects(ViewCellKdNode *n, ObjectContainer &objects);
         
   void
-  CollectLeaves(vector<KdLeaf *> &leaves);
-        
-  AxisAlignedBox3 GetBox(const KdNode *node) const {
-    KdInterior *parent = node->mParent;
+  CollectLeaves(vector<ViewCellKdLeaf *> &leaves);
+        
+  AxisAlignedBox3 GetBox(const ViewCellKdNode *node) const {
+    ViewCellKdInterior *parent = node->mParent;
     if (parent == NULL)
       return mBox;
     
     if (!node->IsLeaf())
-      return ((KdInterior *)node)->mBox;
+      return ((ViewCellKdInterior *)node)->mBox;
     
     AxisAlignedBox3 box(parent->mBox);
@@ -315 +315 @@
   }
         
-  KdNode *
-  FindRandomNeighbor(KdNode *n,
+  ViewCellKdNode *
+  FindRandomNeighbor(ViewCellKdNode *n,
                                                                                  bool onlyUnmailed
                                                                                  );
   
-  KdNode *
-  KdTree::GetRandomLeaf(const Plane3 &halfspace);
-
-        KdNode *
+  ViewCellKdNode *
+  ViewCellKd::GetRandomLeaf(const Plane3 &halfspace);
+
+        ViewCellKdNode *
         GetRandomLeaf(const bool onlyUnmailed = false);
 
   int
-  FindNeighbors(KdNode *n,
-                vector<KdNode *> &neighbors,
+  FindNeighbors(ViewCellKdNode *n,
+                vector<ViewCellKdNode *> &neighbors,
                 bool onlyUnmailed
                 );
@@ -419 +419 @@
 
   struct RayTraversalData {
-    KdNode *mNode;
+    ViewCellKdNode *mNode;
     Vector3 mExitPoint;
     float mMaxT;
     
     RayTraversalData() {}
-    RayTraversalData(KdNode *n,
+    RayTraversalData(ViewCellKdNode *n,
                      const Vector3 &p,
                      const float maxt):
@@ -460 +460 @@
   float
   BestCostRatio(
-                KdLeaf *node,
+                ViewCellKdLeaf *node,
                 const AxisAlignedBox3 &box,
                 const int axis,
@@ -470 +470 @@
   void
   SortSplitCandidates(
-                      KdLeaf *node,
+                      ViewCellKdLeaf *node,
                       const int axis
                       );
@@ -477 +477 @@
   EvaluateLeafStats(const TraversalData &data);
 
-  KdNode *
+  ViewCellKdNode *
   SubdivideNode(
-                KdLeaf *leaf,
+                ViewCellKdLeaf *leaf,
                 const AxisAlignedBox3 &box,
                 AxisAlignedBox3 &backBBox,
@@ -486 +486 @@
 
   bool
-  TerminationCriteriaMet(const KdLeaf *leaf);
+  TerminationCriteriaMet(const ViewCellKdLeaf *leaf);
   
   int
-  SelectPlane(KdLeaf *leaf,
+  SelectPlane(ViewCellKdLeaf *leaf,
               const AxisAlignedBox3 &box,
               float &position
@@ -504 +504 @@
   bool mSahUseFaces;
   /// root of the tree
-  KdNode *mRoot;
+  ViewCellKdNode *mRoot;
   /// bounding box of the tree root
   AxisAlignedBox3 mBox;
-  KdTreeStatistics mStat;
+  ViewCellKdTreeStatistics mStat;
   
 };
-  
-
-
-
-
 
 #endif