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

Timestamp:

11/22/05 20:51:37 (19 years ago)

Author:

bittner

Message:

vss updates

File:

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

trunk/VUT/GtpVisibilityPreprocessor/src/VssPreprocessor.cpp

@@ -10 +10 @@
 #include "VssTree.h"
 
+
+bool useViewSpaceBox = true;
+bool use2dSampling = false;
+bool useViewspacePlane = false;
+
 VssPreprocessor::VssPreprocessor():
         mPass(0),
@@ -18 +23 @@
   environment->GetIntValue("VssPreprocessor.initialSamples", mInitialSamples);
   environment->GetIntValue("VssPreprocessor.vssSamples", mVssSamples);
+  environment->GetIntValue("VssPreprocessor.vssSamplesPerPass", mVssSamplesPerPass);
         environment->GetBoolValue("VssPreprocessor.useImportanceSampling", mUseImportanceSampling);
         
@@ -49 +55 @@
         static Ray ray;
         AxisAlignedBox3 box = mKdTree->GetBox();
+
+        AxisAlignedBox3 sbox = box;
+        sbox.Enlarge(Vector3(-Limits::Small));
+        if (!sbox.IsInside(viewPoint))
+                return 0;
         
         SetupRay(ray, viewPoint, direction);
@@ -145 +156 @@
 
 Vector3
-VssPreprocessor::GetDirection(const Vector3 &viewpoint)
-{
-        int i = RandomValue(0, mObjects.size()-1);
-        Intersectable *object = mObjects[i];
-        Vector3 point, normal;
-        object->GetRandomSurfacePoint(point, normal);
+VssPreprocessor::GetDirection(const Vector3 &viewpoint,
+                                                                                                                        AxisAlignedBox3 *viewSpaceBox
+                                                                                                                        )
+{
+        Vector3 point;
+        if (!use2dSampling) {
+                Vector3 normal;
+                int i = RandomValue(0, mObjects.size()-1);
+                Intersectable *object = mObjects[i];
+                object->GetRandomSurfacePoint(point, normal);
+        } else {
+                AxisAlignedBox3 box;
+                
+                if (viewSpaceBox)
+                        box =*viewSpaceBox;
+                else 
+                        box = mKdTree->GetBox();
+                
+                point = box.GetRandomPoint();
+                point.y = viewpoint.y;
+        }
+        
         return point - viewpoint;
 }
 
 int
-VssPreprocessor::RandomizedImportanceSampling(VssTree *vssTree,
-                                                                                                                                                                                        const int desiredSamples)
-{
-        float minRayContribution;
-        float maxRayContribution;
-        float avgRayContribution;
-
-        vssTree->GetRayContributionStatistics(minRayContribution,
-                                                                                                                                                                maxRayContribution,
-                                                                                                                                                                avgRayContribution);
-
-        cout<<
-                "#MIN_RAY_CONTRIB\n"<<minRayContribution<<endl<<
-                "#MAX_RAY_CONTRIB\n"<<maxRayContribution<<endl<<
-                "#AVG_RAY_CONTRIB\n"<<avgRayContribution<<endl;
-        
-        float p = desiredSamples/(float)(avgRayContribution*vssTree->stat.Leaves());
-        SimpleRayContainer rays;
-        int num = vssTree->GenerateRays(p, rays);
+VssPreprocessor::GenerateImportanceRays(VssTree *vssTree,
+                                                                                                                                                                const int desiredSamples,
+                                                                                                                                                                SimpleRayContainer &rays
+                                                                                                                                                                )
+{
+        int num;
+        if (0) {
+                float minRayContribution;
+                float maxRayContribution;
+                float avgRayContribution;
+                
+                vssTree->GetRayContributionStatistics(minRayContribution,
+                                                                                                                                                                        maxRayContribution,
+                                                                                                                                                                        avgRayContribution);
+                
+                cout<<
+                        "#MIN_RAY_CONTRIB\n"<<minRayContribution<<endl<<
+                        "#MAX_RAY_CONTRIB\n"<<maxRayContribution<<endl<<
+                        "#AVG_RAY_CONTRIB\n"<<avgRayContribution<<endl;
+                
+                float p = desiredSamples/(float)(avgRayContribution*vssTree->stat.Leaves());
+                num = vssTree->GenerateRays(p, rays);
+        } else {
+                int leaves = vssTree->stat.Leaves()/2;
+                num = vssTree->GenerateRays(desiredSamples, leaves, rays);
+        }
+        
         cout<<"Generated "<<num<<" rays."<<endl;
         
-        VssRayContainer  vssRays;
-        
-        for (int i=0; i < rays.size(); i++)
-                CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);
-
-        vssTree->AddRays(vssRays);
         return num;
 }
 
+
+bool
+VssPreprocessor::ExportRays(const char *filename,
+                                                                                                                const VssRayContainer &vssRays,
+                                                                                                                const int number
+                                                                                                                )
+{
+        cout<<"Exporting vss rays..."<<endl<<flush;
+        
+        float prob = number/(float)vssRays.size();
+
+
+        Exporter *exporter = NULL;
+        exporter = Exporter::GetExporter(filename);
+        //      exporter->SetWireframe();
+        //      exporter->ExportKdTree(*mKdTree);
+        exporter->SetFilled();
+        exporter->ExportScene(mSceneGraph->mRoot);
+        exporter->SetWireframe();
+
+        if (mViewSpaceBox) {
+                exporter->SetForcedMaterial(RgbColor(1,0,0));
+                exporter->ExportBox(*mViewSpaceBox);
+                exporter->ResetForcedMaterial();
+        }
+        
+        VssRayContainer rays;   for (int i=0; i < vssRays.size(); i++)
+                if (RandomValue(0,1) < prob)
+                        rays.push_back(vssRays[i]);
+
+        exporter->ExportRays(rays, RgbColor(1, 0, 0));
+        
+        delete exporter;
+
+        cout<<"done."<<endl<<flush;
+
+        return true;
+}
+
+
+bool
+VssPreprocessor::ExportVssTreeLeaf(char *filename,
+                                                                                                                                         VssTree *tree,
+                                                                                                                                         VssTreeLeaf *leaf)
+{
+        Exporter *exporter = NULL;
+        exporter = Exporter::GetExporter(filename);
+        exporter->SetWireframe();
+        exporter->ExportKdTree(*mKdTree);
+        
+        if (mViewSpaceBox) {
+                exporter->SetForcedMaterial(RgbColor(1,0,0));
+                exporter->ExportBox(*mViewSpaceBox);
+                exporter->ResetForcedMaterial();
+        }
+        
+        exporter->SetForcedMaterial(RgbColor(0,0,1));
+        exporter->ExportBox(tree->GetBBox(leaf));
+        exporter->ResetForcedMaterial();
+        
+        VssRayContainer rays[4];
+        for (int i=0; i < leaf->rays.size(); i++) {
+                int k = leaf->rays[i].GetRayClass();
+                rays[k].push_back(leaf->rays[i].mRay);
+        }
+        
+        // SOURCE RAY
+        exporter->ExportRays(rays[0], RgbColor(1, 0, 0));
+        // TERMINATION RAY
+        exporter->ExportRays(rays[1], RgbColor(1, 1, 1));
+        // PASSING_RAY
+        exporter->ExportRays(rays[2], RgbColor(1, 1, 0));
+        // CONTAINED_RAY
+        exporter->ExportRays(rays[3], RgbColor(0, 0, 1));
+
+        delete exporter;
+        return true;
+}
+
+void
+VssPreprocessor::ExportVssTreeLeaves(VssTree *tree, const int number)
+{
+        vector<VssTreeLeaf *> leaves;
+        tree->CollectLeaves(leaves);
+
+        int num = 0;
+        int i;
+        float p = number / (float)leaves.size();
+        for (i=0; i < leaves.size(); i++) {
+                if (RandomValue(0,1) < p) {
+                        char filename[64];
+                        sprintf(filename, "vss-leaf-%04d.x3d", num);
+                        ExportVssTreeLeaf(filename, tree, leaves[i]);
+                        num++;
+                }
+                if (num >= number)
+                        break;
+        }
+}
 
 bool
@@ -196 +324 @@
   int totalSamples = 0;
 
-        AxisAlignedBox3 *viewSpaceBox = NULL;
-
-        AxisAlignedBox3 box = mKdTree->GetBox();
-
-        
-        if (1)
-                box.Enlarge(box.Size()*-Vector3(0.45, 0.45, 0.45));
-        else {
+
+        AxisAlignedBox3 *box = new AxisAlignedBox3(mKdTree->GetBox());
+
+        if (!useViewspacePlane) {
+                float size = 0.01f;
+                float s = 0.5f - size;
+                float olds = Magnitude(box->Size());
+                box->Enlarge(box->Size()*Vector3(-s));
+                Vector3 translation = Vector3(-olds*0.1f, 0, 0);
+                box->SetMin(box->Min() + translation);
+                box->SetMax(box->Max() + translation);
+        } else {
+                
                 // sample city like heights
-                box.SetMin(1, box.Min(1) + box.Size(1)*0.1);
-                box.SetMax(1, box.Min(1) + box.Size(1)*0.2);
-        }
-        
-        bool useViewSpaceBox = false;
+                box->SetMin(1, box->Min(1) + box->Size(1)*0.1);
+                box->SetMax(1, box->Min(1) + box->Size(1)*0.2);
+        }
+
+        if (use2dSampling)
+                box->SetMax(1, box->Min(1));
+        
         if (useViewSpaceBox)
-                viewSpaceBox = &box;
+                mViewSpaceBox = box;
+        else
+                mViewSpaceBox = NULL;
+                
 
         VssTree *vssTree = NULL;
@@ -223 +361 @@
                 int sampleContributions;
                 
-                
-                for (int k=0; k < mSamplesPerPass; k++) {
+                int s = Min(mSamplesPerPass, mInitialSamples);
+                for (int k=0; k < s; k++) {
                         
-                        Vector3 viewpoint = GetViewpoint(viewSpaceBox);
-                        Vector3 direction = GetDirection(viewpoint);
+                        Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
+                        Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
                         
                         sampleContributions = CastRay(viewpoint, direction, mVssRays);
@@ -271 +409 @@
         cout << "#totalRayStackSize=" << mVssRays.size() << endl <<flush;
 
-        cout<<"Exporting vss rays..."<<endl<<flush;
-        
-        int exportRays = 10000;
-
-        if (exportRays) {
-                float prob = exportRays/(float)mVssRays.size();
-                
-                Exporter *exporter = NULL;
-                exporter = Exporter::GetExporter("vss-rays.x3d");
-                exporter->SetWireframe();
-                exporter->ExportKdTree(*mKdTree);
-                if (viewSpaceBox) {
-                        exporter->SetForcedMaterial(RgbColor(1,0,0));
-                        exporter->ExportBox(*viewSpaceBox);
-                        exporter->ResetForcedMaterial();
-                }
-                VssRayContainer rays;
-                for (int i=0; i < mVssRays.size(); i++)
-                        if (RandomValue(0,1) < prob)
-                                rays.push_back(mVssRays[i]);
-                exporter->ExportRays(rays, RgbColor(1, 0, 0));
-
-                delete exporter;
-        }
-        cout<<"done."<<endl<<flush;
+        
+        //      int numExportRays = 10000;
+
+        int numExportRays = 0;
+
+        if (numExportRays) {
+                char filename[64];
+                sprintf(filename, "vss-rays-initial.x3d");
+                ExportRays(filename, mVssRays, numExportRays);
+        }
 
 
@@ -302 +425 @@
         vssTree = new VssTree;
         
-        vssTree->Construct(mVssRays, viewSpaceBox);
+        vssTree->Construct(mVssRays, mViewSpaceBox);
 
         cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
 
+        ExportVssTreeLeaves(vssTree, 10);
         
         int samples = 0;
+        int pass = 0;
         while (1) {
-                int num = mSamplesPerPass;
+                int num = mVssSamplesPerPass;
+                SimpleRayContainer rays;
+                VssRayContainer vssRays;
+                
                 if (!mUseImportanceSampling) {
-                        VssRayContainer vssRays;
                         for (int j=0; j < num; j++) {
-                                Vector3 viewpoint = GetViewpoint(viewSpaceBox);
-                                Vector3 direction = GetDirection(viewpoint);
-                                CastRay(viewpoint, direction, vssRays);
+                                Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
+                                Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
+                                rays.push_back(SimpleRay(viewpoint, direction));
                         }
-                        vssTree->AddRays(vssRays);
                 } else {
-                        num = RandomizedImportanceSampling(vssTree, num);
-                }
+                        num = GenerateImportanceRays(vssTree, num, rays);
+                }
+                
+                
+                for (int i=0; i < rays.size(); i++)
+                        CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);
+                
+                vssTree->AddRays(vssRays);
+                
+                if (1) {
+                        int subdivided = vssTree->UpdateSubdivision();
+                        cout<<"subdivided leafs = "<<subdivided<<endl;
+                }
+                
+                if (numExportRays) {
+                        char filename[64];
+                        if (mUseImportanceSampling)
+                                sprintf(filename, "vss-rays-i%04d.x3d", pass);
+                        else
+                                sprintf(filename, "vss-rays-%04d.x3d", pass);
+                        
+                        ExportRays(filename, vssRays, numExportRays);
+                }
+
+                
                 samples+=num;
                 float pvs = vssTree->GetAvgPvsSize();
+                cout<<"*****************************\n";
                 cout<<samples<<" avgPVS ="<<pvs<<endl;
+                cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
+                cout<<"*****************************\n";
                 if (samples >= mVssSamples)
                         break;
+                pass++;
         }