Changeset 404 for trunk/VUT/GtpVisibilityPreprocessor

Timestamp:

11/10/05 19:01:38 (19 years ago)

Author:

mattausch

Message:

fixed some bugs in pvs criterium, take other ray plane candidates

Location:

trunk/VUT/GtpVisibilityPreprocessor

Files:

• scripts/default.env (modified) (1 diff)
• src/Polygon3.cpp (modified) (3 diffs)
• src/Polygon3.h (modified) (1 diff)
• src/SamplingPreprocessor.cpp (modified) (1 diff)
• src/ViewCellBsp.cpp (modified) (10 diffs)

trunk/VUT/GtpVisibilityPreprocessor/scripts/default.env

@@ -128 +128 @@
         splitPlaneStrategy 1024
         
-        maxPolyCandidates 50
+        maxPolyCandidates 0
         maxRayCandidates 50
         
         Termination {
                 # autopartition
-                maxRays 100
-                maxPolygons 10
-                maxDepth 50
-                minPvs 20
-                minArea 0.001
+                maxRays 300
+                maxPolygons -1
+                maxDepth 40
+                minPvs 35
+                minArea 0.005
                 
                 # axis aligned splits

trunk/VUT/GtpVisibilityPreprocessor/src/Polygon3.cpp

@@ -136 +136 @@
 }
 
-int Polygon3::ClassifyPlane(const Plane3 &plane) const
+int Polygon3::ClassifyPlane(const Plane3 &plane, const float tolerance) const
 {
         VertexContainer::const_iterator it;
@@ -147 +147 @@
         for (it = mVertices.begin(); it != mVertices.end(); ++ it)
         {
-                const int side = plane.Side(*it, Vector3::sDistTolerance);
+                const int side = plane.Side(*it, tolerance);
                 
                 if (side > 0)
@@ -176 +176 @@
         
         return COINCIDENT; // plane and polygon are coincident
+}
+
+int Polygon3::ClassifyPlane(const Plane3 &plane) const
+{
+        return ClassifyPlane(plane, Vector3::sDistTolerance);
 }
 

trunk/VUT/GtpVisibilityPreprocessor/src/Polygon3.h

@@ -65 +65 @@
         */
         int ClassifyPlane(const Plane3 &plane) const;
+
+
+        
+        /** Classify polygon with respect to the plane.
+            @returns one of BACK_SIDE, FRONT_SIDE, SPLIT, COINCIDENT
+        */
+        int ClassifyPlane(const Plane3 &plane, const float tolerance) const;
 
         /** Side of the polygon with respect to the plane.

trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.cpp

@@ -912 +912 @@
                         exporter->SetForcedMaterial(m);
 
-                        //exporter->SetWireframe();
+                        // exporter->SetWireframe();
+                        exporter->SetFilled();
 
                         // output PVS of view cell

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -872 +872 @@
 
 
+        //-- create front and back leaf
 
         BspInterior *parent = leaf->GetParent();
@@ -1089 +1090 @@
         Plane3 bestPlane;
         
-        int limit = sMaxPolyCandidates > 0 ? 
-                Min((int)data.mPolygons->size(), sMaxPolyCandidates) : (int)data.mPolygons->size();
+        int limit = Min((int)data.mPolygons->size(), sMaxPolyCandidates);
         
         int candidateIdx = limit;
@@ -1096 +1096 @@
         for (int i = 0; i < limit; ++ i)
         {
+                Debug << i << " ";
                 candidateIdx = GetNextCandidateIdx(candidateIdx, *data.mPolygons);
                 
@@ -1119 +1120 @@
                 Plane3 plane;
 
-                if (1)
+                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())
-                                        pt[j] = (*rays)[idx[j]]->mRay->Extrap((*rays)[idx[j]]->mMinT);
+                                if (idx[j] >= (int)rays->size())
+                                {
+                                        idx[j] -= (int)rays->size();
+                                        
+                                        chooseMin = (cminT < 2);
+                                }
                                 else
-                                {       
-                                        idx[j] -= (int)rays->size();
-                                        pt[j] = (*rays)[idx[j]]->mRay->Extrap((*rays)[idx[j]]->mMaxT);
-                                }
+                                        chooseMin = (cmaxT < 2);
+
+                                BoundedRay *bRay = (*rays)[idx[j]];
+                                pt[j] = chooseMin ? bRay->mRay->Extrap(bRay->mMinT) : bRay->mRay->Extrap(bRay->mMaxT);
                         }       
                         
@@ -1431 +1439 @@
 
                 // give penalty for unbalanced cell
-                if (((pFront * 0.2) > pBack) || (pFront < (pBack * 0.2)))
+                if (((pFront * 0.2 + 0.00001) > pBack) || (pFront < (pBack * 0.2 + 0.00001)))
                         val += 0.5;
         }
-/*      Debug << "totalpvs: " << pvs << " ptotal: " << pOverall
+
+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);
+                }
+
+        }
+
+        Debug << "totalpvs: " << pvs << " ptotal: " << pOverall
                   << " frontpvs: " << frontPvs << " pFront: " << pFront 
                   << " backpvs: " << backPvs << " pBack: " << pBack 
-                  << " val " << val << endl;
-*/
+                  << " val " << val << " new size: " << ComputePvsSize(rays)
+                  << " fp " << fpvs << " bp " << bpvs << endl << endl;
+
+}
         return val;
 }
@@ -1450 +1499 @@
                                          const int frontAndBackId) const
 {
-        if (cf == Ray::COINCIDENT) //TODO: really belongs to no pvs?
-                return;
+        // TODO: does this really belong to no pvs?
+        //if (cf == Ray::COINCIDENT) return;
 
         if (cf == Ray::FRONT)
@@ -1479 +1528 @@
                 }
         }
-        // object belongs to both pvs
-        else if ((cf == Ray::FRONT_BACK) || (cf == Ray::BACK_FRONT))
+        // object belongs to both PVS
+        else if ((cf == Ray::FRONT_BACK) || (cf == Ray::BACK_FRONT) ||(cf == Ray::COINCIDENT))
         {
                 if (obj.mMailbox !=  frontAndBackId)
@@ -2362 +2411 @@
         for (int i = 0; i < (int)mPolys.size(); ++ i)
         {
-                const int cf = mPolys[i]->ClassifyPlane(splitPlane);
+                const int cf = mPolys[i]->ClassifyPlane(splitPlane, 0.00001);
                         
                 // split new polygon with all previous planes
@@ -2395 +2444 @@
                         case Polygon3::COINCIDENT:
                                 //front.mPolys.push_back(CreateReversePolygon(mPolys[i]));
-                                //back.mPolys.push_back(new Polygon3(mPolys[i]->mVertices));
+                                back.mPolys.push_back(new Polygon3(mPolys[i]->mVertices));
                                 break;
                         default:
@@ -2424 +2473 @@
 
                 const int cf = 
-                        planePoly->ClassifyPlane(plane);
+                        planePoly->ClassifyPlane(plane, 0.00001);
                         
                 // split new polygon with all previous planes