Changeset 2017 for GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

Timestamp:

01/22/07 23:35:03 (17 years ago)

Author:

mattausch

Message:

changed to static cast

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp (modified) (29 diffs)

GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

@@ -238 +238 @@
                 mEvaluationSamplingType = SamplingStrategy::REVERSE_OBJECT_BASED_DISTRIBUTION;
         }
-        /*else if (strcmp(buf, "interior") == 0)
-        {
-                mEvaluationSamplingType = SamplingStrategy::OBJECTS_INTERIOR_DISTRIBUTION;
-        }*/
         else
         {
@@ -311 +307 @@
 
 
+ViewCell *ViewCellsManager::GetViewCellById(const int id)
+{
+        ViewCellContainer::const_iterator vit, vit_end = mViewCells.end();
+
+        for (vit = mViewCells.begin(); vit != vit_end; ++ vit)
+        {
+                if ((*vit)->GetId() == id)
+                        return (*vit);
+        }
+        return NULL;
+}
+
+
+bool ViewCellsManager::ExportRandomViewCells(const string &filename,
+                                                                                         const vector<ViewCellPoints *> &viewCells)
+{
+        std::ofstream outStream;
+        outStream.open(filename.c_str());
+
+        vector<ViewCellPoints *>::const_iterator vit, vit_end = viewCells.end();
+    
+        for (vit = viewCells.begin(); vit != vit_end; ++ vit)
+        {
+                ViewCell *vc = (*vit)->first;
+
+                outStream << "v " << vc->GetId() << endl;
+
+                SimpleRayContainer viewPoints;
+        
+                SimpleRayContainer::const_iterator pit, pit_end = (*vit)->second.end();
+
+                for (pit = (*vit)->second.begin(); pit != pit_end; ++ pit)
+                {
+                        const Vector3 pt = (*pit).mOrigin;
+                        const Vector3 dir = (*pit).mDirection;
+
+                        outStream << "p " << pt.x  << " " << pt.y  << " " << pt.z 
+                                      << " "  << dir.x << " " << dir.y << " " << dir.z << endl;
+                }
+        }
+
+        return true;
+}
+
+
+bool ViewCellsManager::GenerateRandomViewCells(vector<ViewCellPoints *> &viewCells,
+                                                                                           const int nViewCells,
+                                                                                           const int nViewPoints)
+{
+        ViewCellContainer rViewCells;
+
+        cout << "generating " << nViewCells << " random view cells" << endl;
+        GenerateRandomViewCells(rViewCells, nViewCells);
+
+        cout << "finished" << endl;
+
+        //for (int i = 0; i < viewCells.size(); ++ i)
+        //      cout << "vc " << i << ": " << viewCells[i]->GetId() << endl;
+
+        cout << "generating " << nViewPoints << " view points per view cell" << endl;
+        ViewCellContainer::const_iterator vit, vit_end = rViewCells.end();
+    
+        for (vit = rViewCells.begin(); vit != vit_end; ++ vit)
+        {
+                ViewCell *vc = *vit;
+
+                ViewCellPoints *vcPts = new ViewCellPoints();
+                viewCells.push_back(vcPts);
+
+                vcPts->first = vc;
+
+                SimpleRayContainer viewPoints;
+                // generate random view points
+                GenerateViewPoints(vc, nViewPoints, viewPoints);
+                
+                SimpleRayContainer::const_iterator pit, pit_end = viewPoints.end();
+
+                for (pit = viewPoints.begin(); pit != pit_end; ++ pit)
+                {
+                        vcPts->second.push_back(*pit);  
+                }
+        }
+
+        return true;
+}
+
+
+bool ViewCellsManager::ImportRandomViewCells(const string &filename, 
+                                                                                         vector<ViewCellPoints *> &viewCells)
+{
+        ifstream inStream(filename.c_str());
+        if (!inStream.is_open())
+                return false;
+
+        ViewCellPoints *currentViewCell = NULL;
+
+        string buf;
+        while (!(getline(inStream, buf)).eof())
+        {
+                switch (buf[0])
+                {
+                case 'v':
+                        {
+                                int id;
+                                sscanf(buf.c_str(), "v %d", &id);
+                        
+                                currentViewCell = new ViewCellPoints();
+                                currentViewCell->first = GetViewCellById(id);
+                                                
+                                viewCells.push_back(currentViewCell);
+                                break;
+                        }
+                case 'p':
+                        {
+                                Vector3 pt, dir;
+                                sscanf(buf.c_str(), "p %f %f %f %f %f %f", &pt.x, &pt.y, &pt.z, &dir.x, &dir.y, &dir.z);
+                                
+                                SimpleRay ray(pt, dir, 0, 1);
+                                currentViewCell->second.push_back(ray);
+                                break;
+                        }
+                default:
+                        break;
+                }
+        }
+
+        return true;
+}
+
+
+bool ViewCellsManager::GenerateViewPoints(ViewCell *viewCell, 
+                                                                                  const int numViewPoints,
+                                                                                  SimpleRayContainer &viewPoints)
+{
+        bool success = true;
+        int generatedPts = 0;
+        int i = 0;
+
+        while (generatedPts < numViewPoints)
+        {
+                SimpleRay pt;
+
+                if (GenerateViewPoint(viewCell, pt))
+                {
+                        ++ generatedPts;
+                        viewPoints.push_back(pt);
+                }
+
+                // savety criterium
+                if (++ i > numViewPoints + 100000)
+                {
+                        return false;
+                }
+        }
+        
+        return true;
+}
+
+
+bool ViewCellsManager::GenerateViewPoint(ViewCell *viewCell, 
+                                                                                 SimpleRay &ray)
+{
+        // do not use this function since it could return different viewpoints for
+        // different executions of the algorithm
+        int tries = 0;
+        Vector3 viewPoint, direction;
+        const int maxTries = 100;
+
+        while (1) 
+        {
+                // hack
+                if (!viewCell->GetMesh())
+                        CreateMesh(viewCell);
+
+        Mesh *mesh = viewCell->GetMesh();
+                AxisAlignedBox3 box = mesh->mBox;
+                //cout <<"box: " << box << endl;
+                /*Vector3 pVector = Vector3(halton.GetNumber(1),
+                                                                  halton.GetNumber(2),
+                                                                  halton.GetNumber(3));*/
+
+                Vector3 pVector = Vector3(Random(1.0f),
+                                                                  Random(1.0f),
+                                                                  Random(1.0f));
+
+                viewPoint =  box.GetPoint(pVector);
+        
+                //const Vector3 dVector = Vector3(2 * M_PI * halton.GetNumber(4), M_PI*halton.GetNumber(5),0.0f);
+                const Vector3 dVector = Vector3(2 * M_PI * Random(1.0f), M_PI * Random(1.0f), 0.0f);
+                direction = Normalize(Vector3(sin(dVector.x), 0.0f, cos(dVector.x)));
+                //halton.GenerateNext();
+
+                //cout << "vp: " << viewPoint << endl;
+                //cout << "dir: " << direction << endl;
+
+                ViewCell *v = GetViewCell(viewPoint);
+
+                if (v && v->GetValid())
+                {
+                        //cout << "validating view point" << endl;
+
+                        mPreprocessor->GetRenderer()->mViewPoint = viewPoint;
+                        mPreprocessor->GetRenderer()->mViewDirection = direction;
+
+                        if (mPreprocessor->GetRenderer()->ValidViewPoint())
+                        {
+                                cout << "view point valid" << endl;
+                                break;
+                        }
+                }
+
+                // generate a new vector
+                //halton.GenerateNext();
+
+                //if (!box.IsInside(viewPoint))
+                //      cout << "error!" << endl;
+                if (++ tries > maxTries)
+                        return false;
+        }
+
+        ray = SimpleRay(viewPoint, direction, 0, 1);
+        //cout << "view point generated: " << viewPoint << " " << direction << endl;
+
+        return true;
+}
+
+
+bool ViewCellsManager::IsValidViewSpace(ViewCell *vc)
+{
+        SimpleRay simpleRay;
+        //check if view point can be generated
+        return GenerateViewPoint(vc, simpleRay);
+}
+
+
+bool ViewCellsManager::GenerateRandomViewCells(ViewCellContainer &viewCells, 
+                                                                                           const int numViewCells)
+{
+        int generatedViewCells = 0;
+        //HaltonSequence halton;
+        //float r[1];
+
+        ViewCell::NewMail();
+
+        while (generatedViewCells < numViewCells)
+        {
+                // savety criterium
+                const int tries = 100000 + generatedViewCells;
+                int i = 0;
+
+                // generate next view cell
+                while (1)
+                {
+                        //halton.GetNext(1, r);
+                        //const int idx = (int)(r[0] * mViewCells.size() - 1.0f);
+                        const int idx = (int)RandomValue(0.0f, (float)mViewCells.size() - 0.5f);
+                        
+                        ViewCell *viewCell = GetViewCell(idx);
+
+                        if (!viewCell->Mailed())
+                        {
+                                viewCell->Mail();
+
+                                // check for valid view space
+                                if (IsValidViewSpace(viewCell))
+                                {
+                                        // valid view cell found
+                                        viewCells.push_back(viewCell);
+
+                        ++ generatedViewCells;
+                                        //cout << "view cell " << generatedViewCells << " generated: " << viewCell->GetId() << endl;    
+                                        break;
+                                }
+                                else
+                                {
+                                        cout << "error: invalid view cell " << generatedViewCells << " generated: " << viewCell->GetId() << endl;       
+                                }
+                        }
+
+                        if (++ i == tries) // no new view cell fond
+                        {
+                                cerr << "big error! no view cell found" << endl;
+                                return false;
+                        }               
+                }                       
+        }
+
+        return true;
+}
+
+
 ViewCellsManager::~ViewCellsManager()
 {
@@ -575 +862 @@
                 mRenderer->RenderScene();
                 SimulationStatistics ss;
-                dynamic_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
+                static_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
 
                 Debug << ss << endl;
@@ -1616 +1903 @@
                         if ((*oit)->Type() == Intersectable::TRANSFORMED_MESH_INSTANCE)
                         {
-                                TransformedMeshInstance *mit = dynamic_cast<TransformedMeshInstance *>(*oit);
+                                TransformedMeshInstance *mit = static_cast<TransformedMeshInstance *>(*oit);
                                 mesh = MeshManager::GetSingleton()->CreateResource();
                                 mit->GetTransformedMesh(*mesh);
@@ -1622 +1909 @@
                         else if ((*oit)->Type() == Intersectable::MESH_INSTANCE)
                         {
-                                MeshInstance *mit = dynamic_cast<MeshInstance *>(*oit);
+                                MeshInstance *mit = static_cast<MeshInstance *>(*oit);
                                 mesh = mit->GetMesh();
                         }
@@ -2608 +2895 @@
         for (lit = leaves.begin(); lit != lit_end; ++ lit)
         {
-                dynamic_cast<ViewCellLeaf *>(*lit)->SetActiveViewCell(vc);
+                static_cast<ViewCellLeaf *>(*lit)->SetActiveViewCell(vc);
         }
 }
@@ -2648 +2935 @@
                 for (it = objects.begin(); it != it_end; ++ it)
                 {
-                        MeshInstance *mi = dynamic_cast<MeshInstance *>(*it);
+                        MeshInstance *mi = static_cast<MeshInstance *>(*it);
                         const AxisAlignedBox3 box = mi->GetBox();
 
@@ -2671 +2958 @@
                 for (it = objects.begin(); it != it_end; ++ it)
                 {       
-                        MeshInstance *mi = dynamic_cast<MeshInstance *>(*it);
+                        MeshInstance *mi = static_cast<MeshInstance *>(*it);
                         const AxisAlignedBox3 box = mi->GetBox();
                         Vector3 bmin = box.Min();
@@ -3252 +3539 @@
         //-- interior node => propagate pvs up the tree
 
-        ViewCellInterior *interior = dynamic_cast<ViewCellInterior *>(root);
+        ViewCellInterior *interior = static_cast<ViewCellInterior *>(root);
 
         // reset interior pvs
@@ -3920 +4207 @@
 
         Mesh *mesh = MeshManager::GetSingleton()->CreateResource();
-
+        
         IncludeNodeGeomInMesh(geom, *mesh);
+        mesh->ComputeBoundingBox();
+
         vc->SetMesh(mesh);
 }
@@ -4101 +4390 @@
         if (root->IsLeaf())
         {
-                BspLeaf *leaf = dynamic_cast<BspLeaf *>(root);
+                BspLeaf *leaf = static_cast<BspLeaf *>(root);
                 leaf->GetViewCell()->SetMergeCost(0.0f);
                 return leaf->GetViewCell();
         }
         
-        BspInterior *interior = dynamic_cast<BspInterior *>(root);
+        BspInterior *interior = static_cast<BspInterior *>(root);
         ViewCellInterior *viewCellInterior = new ViewCellInterior();
                 
@@ -4243 +4532 @@
 
                 for (int i = 0; i < leafOut; ++ i)
-                        kdLeaves.push_back(dynamic_cast<KdLeaf *>(mKdTree->GetRandomLeaf()));
+                        kdLeaves.push_back(static_cast<KdLeaf *>(mKdTree->GetRandomLeaf()));
 
                 for (int i = 0; i < kdLeaves.size(); ++ i)
@@ -4406 +4695 @@
         for (it = leaves.begin(); it != it_end; ++ it)
         {
-                KdViewCell *kdVc = dynamic_cast<KdViewCell *>(*it);
+                KdViewCell *kdVc = static_cast<KdViewCell *>(*it);
                 exporter->ExportBox(mKdTree->GetBox(kdVc->mLeaves[0]));
         }
@@ -4746 +5035 @@
 
         SimulationStatistics ss;
-        dynamic_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
+        static_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
     Debug << "render time before refine\n\n" << ss << endl;
 
@@ -4826 +5115 @@
 
         cout << "\nview cells partition render time before compress" << endl << endl;;
-        dynamic_cast<RenderSimulator *>(mRenderer)->RenderScene();
+        static_cast<RenderSimulator *>(mRenderer)->RenderScene();
         SimulationStatistics ss;
-        dynamic_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
+        static_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
         cout << ss << endl;
         
@@ -4857 +5146 @@
         if (root->IsLeaf())
         {
-                BspLeaf *leaf = dynamic_cast<BspLeaf *>(root);
+                BspLeaf *leaf = static_cast<BspLeaf *>(root);
                 leaf->GetViewCell()->SetMergeCost(0.0f);
                 return leaf->GetViewCell();
@@ -4863 +5152 @@
         
         
-        BspInterior *interior = dynamic_cast<BspInterior *>(root);
+        BspInterior *interior = static_cast<BspInterior *>(root);
         ViewCellInterior *viewCellInterior = new ViewCellInterior();
                 
@@ -5095 +5384 @@
                 for (vit = leaves.begin(); vit != vit_end; ++ vit)
                         {       
-                                BspLeaf *vcLeaf = dynamic_cast<BspViewCell *>(*vit)->mLeaves[0];
+                                BspLeaf *vcLeaf = static_cast<BspViewCell *>(*vit)->mLeaves[0];
                                 VssRayContainer::const_iterator rit, rit_end = vcLeaf->mVssRays.end();
 
@@ -5387 +5676 @@
                 for (int j = 0; j < (int)leaves.size(); ++ j)
                 {
-                        BspLeaf *leaf = dynamic_cast<BspViewCell *>(leaves[i])->mLeaves[0];
+                        BspLeaf *leaf = static_cast<BspViewCell *>(leaves[i])->mLeaves[0];
 
                         if (i != j)
                         {
-                                BspLeaf *leaf2 =dynamic_cast<BspViewCell *>(leaves[j])->mLeaves[0];
+                                BspLeaf *leaf2 =static_cast<BspViewCell *>(leaves[j])->mLeaves[0];
                                 const int dist = mVspBspTree->TreeDistance(leaf, leaf2);
                                 
@@ -5422 +5711 @@
         
         Mesh *mesh = MeshManager::GetSingleton()->CreateResource();
+        
         IncludeNodeGeomInMesh(geom, *mesh);
+        mesh->ComputeBoundingBox();
 
         vc->SetMesh(mesh);
@@ -5500 +5791 @@
 {
         // TODO: do I still need this here?
-        if (0)
-                mVspBspTree->RepairViewCellsLeafLists();
+        if (0) mVspBspTree->RepairViewCellsLeafLists();
 }
 
@@ -5748 +6038 @@
 
         cout << "\nview cells partition render time before compress" << endl << endl;
-        dynamic_cast<RenderSimulator *>(mRenderer)->RenderScene();
+        static_cast<RenderSimulator *>(mRenderer)->RenderScene();
         SimulationStatistics ss;
-        dynamic_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
+        static_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
         cout << ss << endl;
         
@@ -5782 +6072 @@
         if (root->IsLeaf())
         {
-                VspLeaf *leaf = dynamic_cast<VspLeaf *>(root);
+                VspLeaf *leaf = static_cast<VspLeaf *>(root);
                 leaf->GetViewCell()->SetMergeCost(0.0f);
                 return leaf->GetViewCell();
         }
         
-        VspInterior *interior = dynamic_cast<VspInterior *>(root);
+        VspInterior *interior = static_cast<VspInterior *>(root);
         ViewCellInterior *viewCellInterior = new ViewCellInterior();
                 
@@ -5861 +6151 @@
         for (it = leaves.begin(); it != it_end; ++ it)
         {
-                VspViewCell *vspVc = dynamic_cast<VspViewCell *>(*it);
+                VspViewCell *vspVc = static_cast<VspViewCell *>(*it);
                 VspLeaf *l = vspVc->mLeaves[0];
 
@@ -5927 +6217 @@
                         ObjectPvsEntry entry = pit.Next();
                                 
-                        BvhNode *node = dynamic_cast<BvhNode *>(entry.mObject);
+                        BvhNode *node = static_cast<BvhNode *>(entry.mObject);
                         
                         // hack!!
@@ -6165 +6455 @@
                         for (vit = leaves.begin(); vit != vit_end; ++ vit)
                         {
-                                VspLeaf *vcLeaf = dynamic_cast<VspViewCell *>(*vit)->mLeaves[0];
+                                VspLeaf *vcLeaf = static_cast<VspViewCell *>(*vit)->mLeaves[0];
                                 VssRayContainer::const_iterator rit, rit_end = vcLeaf->mVssRays.end();
 
@@ -6311 +6601 @@
 void VspOspViewCellsManager::CreateMesh(ViewCell *vc)
 {
-        // matt: TODO
         Mesh *mesh = MeshManager::GetSingleton()->CreateResource();
-
+        
         ViewCellContainer leaves;
         mViewCellsTree->CollectLeaves(vc, leaves);
@@ -6321 +6610 @@
     for (it = leaves.begin(); it != it_end; ++ it)
         {
-                VspLeaf *leaf = dynamic_cast<VspViewCell *>(*it)->mLeaves[0];
+                VspLeaf *leaf = static_cast<VspViewCell *>(*it)->mLeaves[0];
                 const AxisAlignedBox3 box = mHierarchyManager->GetVspTree()->GetBoundingBox(leaf);
         IncludeBoxInMesh(box, *mesh);
         }
 
+        mesh->ComputeBoundingBox();
+
         vc->SetMesh(mesh);
 }
@@ -6349 +6640 @@
     for (it = leaves.begin(); it != it_end; ++ it)
         {
-                VspLeaf *leaf = dynamic_cast<VspViewCell *>(*it)->mLeaves[0];
+                VspLeaf *leaf = static_cast<VspViewCell *>(*it)->mLeaves[0];
                 
                 const AxisAlignedBox3 box = mHierarchyManager->GetVspTree()->GetBoundingBox(leaf);