Changeset 376 for trunk/VUT/GtpVisibilityPreprocessor/src/VssPreprocessor.cpp

Timestamp:

11/03/05 19:31:56 (19 years ago)

Author:

bittner

Message:

vsspreprocessor kdtree meshkdtree optimization

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/VssPreprocessor.cpp (modified) (6 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/VssPreprocessor.cpp

@@ -7 +7 @@
 #include "Polygon3.h"
 #include "ViewCell.h"
+#include "VssRay.h"
 
 VssPreprocessor::VssPreprocessor():
         mPass(0),
-        mSampleRays(NULL)
+        mVssRays()
 {
   // this should increase coherence of the samples
-  environment->GetIntValue("Sampling.samplesPerPass", mSamplesPerPass);
-  environment->GetIntValue("Sampling.totalSamples", mTotalSamples);
-  mKdPvsDepth = 100;
+  environment->GetIntValue("VssPreprocessor.samplesPerPass", mSamplesPerPass);
+  environment->GetIntValue("VssPreprocessor.totalSamples", mTotalSamples);
   mStats.open("stats.log");
-
 }
 
 VssPreprocessor::~VssPreprocessor()
 {
-        CLEAR_CONTAINER(mSampleRays);
+        CLEAR_CONTAINER(mVssRays);
 }
 
@@ -33 +32 @@
   ray.intersections.clear();
         // do not store anything else then intersections at the ray
-        ray.kdLeaves.clear();
-        ray.mFlags = Ray::STORE_KDLEAVES;
-        
-  //  cout<<point<<" "<<direction<<endl;
   ray.Init(point, direction, Ray::LOCAL_RAY);
 }
 
-KdNode *
-VssPreprocessor::GetNodeForPvs(KdLeaf *leaf)
+VssRay * 
+VssPreprocessor::CastRay(
+                                                                                                 Vector3 &viewPoint,
+                                                                                                 Vector3 &direction
+                                                                                                 )
 {
-  KdNode *node = leaf;
-  while (node->mParent && node->mDepth > mKdPvsDepth)
-    node = node->mParent;
-  return node;
+        static Ray ray;
+        AxisAlignedBox3 box = mKdTree->GetBox();
+        
+        SetupRay(ray, viewPoint, direction);
+        // cast ray to KD tree to find intersection with other objects
+        Intersectable *objectA, *objectB;
+        Vector3 pointA, pointB;
+
+        if (mKdTree->CastRay(ray)) {
+                objectA = ray.intersections[0].mObject;
+                pointA = ray.Extrap(ray.intersections[0].mT);
+        } else {
+                objectA = NULL;
+                // compute intersection with the scene bounding box
+                float tmin, tmax;
+                box.ComputeMinMaxT(ray, &tmin, &tmax);
+                pointA = ray.Extrap(tmax);
+        }
+        
+        SetupRay(ray, viewPoint, -direction);
+        
+        if (mKdTree->CastRay(ray)) {
+                objectB = ray.intersections[0].mObject;
+          pointB = ray.Extrap(ray.intersections[0].mT);
+        } else {
+                objectB = NULL;
+                float tmin, tmax;
+                box.ComputeMinMaxT(ray, &tmin, &tmax);
+                pointB = ray.Extrap(tmax);
+        }
+
+        VssRay *vssRay  = NULL;
+        
+        if (objectA || objectB) {
+                vssRay = new VssRay(pointA,
+                                                                                                pointB,
+                                                                                                objectA,
+                                                                                                objectB);
+        }
+        
+        return vssRay;
 }
 
 
-int
-VssPreprocessor::AddNodeSamples(const Ray &ray,
-                                                                                                                                Intersectable *sObject,
-                                                                                                                                Intersectable *tObject
-                                                                                                                                )
+Vector3
+VssPreprocessor::GetViewpoint()
 {
-  int contributingSamples = 0;
-  int j;
-        int objects = 0;
-        if (sObject)
-                objects++;
-        if (tObject)
-                objects++;
+        AxisAlignedBox3 box = mKdTree->GetBox();
+
+        // shrink the box in the y direction
+        Vector3 diff(0, -box.Size().y*0.4f, 0);
+        box.Enlarge(diff);
         
-        if (objects) {
-                for (j=0; j < ray.kdLeaves.size(); j++) {
-                        KdNode *node = GetNodeForPvs( ray.kdLeaves[j] );
-                        if (sObject)
-                                contributingSamples += sObject->mKdPvs.AddSample(node);
-                        if (tObject)
-                                contributingSamples += tObject->mKdPvs.AddSample(node);
-                }
-        }
-        
-        for (j=1; j < ((int)ray.kdLeaves.size() - 1); j++) {
-                ray.kdLeaves[j]->AddPassingRay2(ray,
-                                                                                                                                                objects,
-                                                                                                                                                ray.kdLeaves.size()
-                                                                                                                                                );
-  }
-  
-  return contributingSamples;
+        return box.GetRandomPoint();
+}
+
+Vector3
+VssPreprocessor::GetDirection(const Vector3 &viewpoint)
+{
+        int i = RandomValue(0, mObjects.size());
+        Intersectable *object = mObjects[i];
+        Vector3 point, normal;
+        object->GetRandomSurfacePoint(point, normal);
+        return point - viewpoint;
 }
 
 
-
-
-int
-VssPreprocessor::CastRay(Intersectable *object,
-                                                                                                 Ray &ray
-                                                                                                 )
-{
-        int sampleContributions = 0;
-
-        long t1 = GetRealTime();
-        // cast ray to KD tree to find intersection with other objects
-        mKdTree->CastRay(ray);
-        long t2 = GetRealTime();
-
-        if (0 && object && object->GetId() > 2197) {
-                object->Describe(cout)<<endl;
-                cout<<ray<<endl;
-        }
-
-        if (ray.kdLeaves.size()) {
-                Intersectable *terminator =
-                        ray.intersections.size() ? ray.intersections[0].mObject: NULL;
-                
-                sampleContributions += AddNodeSamples(ray,
-                                                                                                                                                                        object,
-                                                                                                                                                                        terminator);
-        }
-        
-        
-        return sampleContributions;
-}
-
-
-KdNode *
-VssPreprocessor::GetNodeToSample(Intersectable *object)
-{
-        int pvsSize = object->mKdPvs.GetSize();
-        KdNode *nodeToSample = NULL;
-        
-        // just pickup a random node
-        nodeToSample = mKdTree->GetRandomLeaf();
-        return nodeToSample;
-}
 
 bool
@@ -133 +113 @@
 {
   
-  // pickup an object
-  ObjectContainer objects;
-  
-  mSceneGraph->CollectObjects(&objects);
-
-  Vector3 point, normal, direction;
-  Ray ray;
+  mSceneGraph->CollectObjects(&mObjects);
+        
 
   long startTime = GetTime();
@@ -146 +121 @@
   int totalSamples = 0;
 
-  int pvsOut = Min((int)objects.size(), 10);
-
-  vector<Ray> rays[10];
 
   while (totalSamples < mTotalSamples) {
@@ -156 +128 @@
                 int index = 0;
                 
-                int reverseSamples = 0;
+                int sampleContributions;
                 
+                
+                for (int k=0; k < mSamplesPerPass; k++) {
+
+                        Vector3 viewpoint = GetViewpoint();
+                        Vector3 direction = GetDirection(viewpoint);
+
+                        VssRay *vssRay = CastRay(viewpoint, direction);
                         
-                //cout << "totalSamples: "  << totalSamples << endl;
-
-                for (i = 0; i < objects.size(); i++) {
-                                                
-                        KdNode *nodeToSample = NULL;
-                        Intersectable *object = objects[i];
-                
-                        int pvsSize = 0;
-                        if (ViewCell::sHierarchy == ViewCell::KD)
-                                pvsSize = object->mKdPvs.GetSize();
-                                                
+                        if (vssRay) {
+                                sampleContributions = vssRay->HitCount();
+                                mVssRays.push_back(vssRay);
+                        }
                         
-                        
-                        int faceIndex = object->GetRandomSurfacePoint(point, normal);
-                        
-                        bool viewcellSample = true;
-                        int sampleContributions;
-                        bool debug = false; //(object->GetId() >= 2199);
-                        if (viewcellSample) {
-                                //mKdTree->GetRandomLeaf(Plane3(normal, point));
-
-                                nodeToSample = GetNodeToSample(object);
-
-                                for (int k=0; k < mSamplesPerPass; k++) {
-                                        bool reverseSample = false;
-                                        
-
-                                        if (nodeToSample) {
-                                                AxisAlignedBox3 box = mKdTree->GetBox(nodeToSample);
-                                                Vector3 pointToSample = box.GetRandomPoint();
-                                                //                                              pointToSample.y = 0.9*box.Min().y + 0.1*box.Max().y;
-                                                if (object->GetRandomVisibleSurfacePoint( point, normal, pointToSample, 3 )) {
-                                                        direction = pointToSample - point;
-                                                } else {
-                                                        reverseSamples++;
-                                                        reverseSample = true;
-                                                        direction = point - pointToSample;
-                                                        point = pointToSample;
-                                                }
-                                        }
-                                        else {
-                                                direction = UniformRandomVector(normal);
-                                        }
-                                        
-                                        // construct a ray
-                                        SetupRay(ray, point, direction);
-                                        
-                                        sampleContributions = CastRay(reverseSample ? NULL : object, ray);
-                                        
-                                        //-- CORR matt: put block inside loop
-                                        if (sampleContributions) {
-                                                passContributingSamples ++;
-                                                passSampleContributions += sampleContributions;
-                                        }
-
-                                        if ( i < pvsOut )
-                                                rays[i].push_back(ray);
-                
-                                        if (!ray.intersections.empty()) {
-                                                // check whether we can add this to the rays
-                                                for (int j = 0; j < pvsOut; j++) {
-                                                        if (objects[j] == ray.intersections[0].mObject) {
-                                                                rays[j].push_back(ray);
-                                                        }
-                                                }
-                                        }
-                                        //-------------------
-                                }
-                        } else {
-                                // edge samples
-                                // get random visible mesh
-                                //                              object->GetRandomVisibleMesh(Plane3(normal, point));
+                        //-- CORR matt: put block inside loop
+                        if (sampleContributions) {
+                                passContributingSamples ++;
+                                passSampleContributions += sampleContributions;
                         }
-        
-                        // CORR matt: must add all samples
-                        passSamples += mSamplesPerPass;
+                        passSamples++;
+                        totalSamples++;
                 }
-        
-                totalSamples += passSamples; 
-                
-                //    if (pass>10)
-                //      HoleSamplingPass();
     
                 mPass++;
 
                 int pvsSize = 0;
-        
-                for (i=0; i < objects.size(); i++) {
-                        Intersectable *object = objects[i];
-                        pvsSize += object->mKdPvs.GetSize();
-                }
-                
-                
                 float avgRayContrib = (passContributingSamples > 0) ? 
                         passSampleContributions/(float)passContributingSamples : 0;
-
+                
                 cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
                 cout << "#TotalSamples=" << totalSamples/1000 
                                  << "k   #SampleContributions=" << passSampleContributions << " (" 
                                  << 100*passContributingSamples/(float)passSamples<<"%)" << " avgPVS="
-                                 << pvsSize/(float)objects.size() << endl 
-                                 << "avg ray contrib=" << avgRayContrib << endl
-                                 << "reverse samples [%]" << reverseSamples/(float)passSamples*100.0f << endl;
-
+                                 << pvsSize/(float)mObjects.size() << endl 
+                                 << "avg ray contrib=" << avgRayContrib << endl;
+                
                 mStats <<
                         "#Pass\n" <<mPass<<endl<<
@@ -269 +171 @@
                         "#SampleContributions\n" << passSampleContributions << endl << 
                         "#PContributingSamples\n"<<100*passContributingSamples/(float)passSamples<<endl <<
-                        "#AvgPVS\n"<< pvsSize/(float)objects.size() << endl <<
+                        "#AvgPVS\n"<< pvsSize/(float)mObjects.size() << endl <<
                         "#AvgRayContrib\n" << avgRayContrib << endl;
         }
         
         cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
-  
-        
-        if (0) {
-                Exporter *exporter = Exporter::GetExporter("ray-density.x3d"); 
-                exporter->SetExportRayDensity(true);
-                exporter->ExportKdTree(*mKdTree);
+        cout << "#totalRayStackSize=" << mVssRays.size() << endl;
 
-                delete exporter;
-        }
-  
-        bool exportRays = false;
-        if (exportRays) {
-                Exporter *exporter = NULL;
-                exporter = Exporter::GetExporter("sample-rays.x3d");
-                exporter->SetWireframe();
-                exporter->ExportKdTree(*mKdTree);
-
-                for (i=0; i < pvsOut; i++) 
-                exporter->ExportRays(rays[i], 1000, RgbColor(1, 0, 0));
-                exporter->SetFilled();
-                  
-                delete exporter;
-        }
-
-        //-- several visualizations and statistics
-        if (1) {
-                for (int k=0; k < pvsOut; k++) {
-                        Intersectable *object = objects[k];
-                        char s[64];
-                        sprintf(s, "sample-pvs%04d.x3d", k);
-                        Exporter *exporter = Exporter::GetExporter(s);
-                        exporter->SetWireframe();
-                        
-                        
-                        KdPvsMap::iterator i = object->mKdPvs.mEntries.begin();
-                        Intersectable::NewMail();
-                        
-                        // avoid adding the object to the list
-                        object->Mail();
-                        ObjectContainer visibleObjects;
-                        
-                        for (; i != object->mKdPvs.mEntries.end(); i++) 
-                                {
-                                        KdNode *node = (*i).first;
-                                        exporter->ExportBox(mKdTree->GetBox(node));
-                                        mKdTree->CollectObjects(node, visibleObjects);
-                                }
-                        
-                        exporter->ExportRays(rays[k], 1000, RgbColor(0, 1, 0));
-                        exporter->SetFilled();
-                        
-                        for (int j = 0; j < visibleObjects.size(); j++)
-                                exporter->ExportIntersectable(visibleObjects[j]);
-                        
-                        
-                        Material m;
-                        m.mDiffuseColor = RgbColor(1, 0, 0);
-                        exporter->SetForcedMaterial(m);
-                        exporter->ExportIntersectable(object);
-                        
-                        delete exporter;
-                }
-  }
-  
   return true;
 }