Changeset 503 for trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp

Timestamp:

01/05/06 20:41:52 (18 years ago)

Author:

mattausch

Message:

added mesh creation function

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp (modified) (21 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/VspBspTree.cpp

@@ -835 +835 @@
 
 
+/*
 float VspBspTree::EvalCostRatio(const VspBspTraversalData &tData,
                                                                 const AxisAlignedBox3 &box,
@@ -949 +950 @@
         return  (mCtDivCi + newCost) / oldCost;
 }
-
+*/
 
 
@@ -1304 +1305 @@
 
 
-void VspBspTree::CollectLeaves(vector<BspLeaf *> &leaves) const
+void VspBspTree::CollectLeaves(vector<BspLeaf *> &leaves, 
+                                                           const bool onlyUnmailed,
+                                                           const int maxPvsSize) const
 {
         stack<BspNode *> nodeStack;
@@ -1317 +1320 @@
                 {
                         // test if this leaf is in valid view space
-                        if (node->TreeValid())
+                        BspLeaf *leaf = dynamic_cast<BspLeaf *>(node);
+                        if (leaf->TreeValid() && 
+                                (!onlyUnmailed || leaf->Mailed()) &&
+                                ((maxPvsSize < 0) || (leaf->GetViewCell()->GetPvs().GetSize() <= maxPvsSize)))
                         {
-                                BspLeaf *leaf = (BspLeaf *)node;
                                 leaves.push_back(leaf);
                         }
@@ -1641 +1646 @@
 
 void VspBspTree::ConstructGeometry(BspNode *n,
-                                                                   BspNodeGeometry &cell) const
-{
-        ConstructGeometry(n, cell.mPolys);
-}
-
-
-void VspBspTree::ConstructGeometry(BspNode *n,
-                                                                   PolygonContainer &cell) const
+                                                                   BspNodeGeometry &geom) const
 {
         vector<Plane3> halfSpaces;
@@ -1726 +1724 @@
 
                 if (candidatePolys[i])
-                        cell.push_back(candidatePolys[i]);
+                        geom.mPolys.push_back(candidatePolys[i]);
         }
 }
@@ -1732 +1730 @@
 
 void VspBspTree::ConstructGeometry(BspViewCell *vc, 
-                                                                   PolygonContainer &vcGeom) const
+                                                                   BspNodeGeometry &vcGeom) const
 {
         vector<BspLeaf *> leaves = vc->mLeaves;
@@ -1745 +1743 @@
                                                    const bool onlyUnmailed) const
 {
-        PolygonContainer geom;
+        BspNodeGeometry geom;
         ConstructGeometry(n, geom);
 
@@ -1770 +1768 @@
                                 // test all planes of current node if candidate really
                                 // is neighbour
-                                PolygonContainer neighborCandidate;
+                                BspNodeGeometry neighborCandidate;
                                 ConstructGeometry(node, neighborCandidate);
 
@@ -1777 +1775 @@
                                 {
                                         const int cf =
-                                                Polygon3::ClassifyPlane(neighborCandidate,
+                                                Polygon3::ClassifyPlane(neighborCandidate.mPolys,
                                                                                                 halfSpaces[i],
                                                                                                 mEpsilon);
@@ -1787 +1785 @@
                                 if (isAdjacent)
                                         neighbors.push_back(dynamic_cast<BspLeaf *>(node));
-
-                                CLEAR_CONTAINER(neighborCandidate);
                         }
                 }
@@ -1795 +1791 @@
                         BspInterior *interior = dynamic_cast<BspInterior *>(node);
 
-                        const int cf = Polygon3::ClassifyPlane(geom,
+                        const int cf = Polygon3::ClassifyPlane(geom.mPolys,
                                                                                                    interior->GetPlane(),
                                                                                                    mEpsilon);
@@ -1813 +1809 @@
         }
 
-        CLEAR_CONTAINER(geom);
         return (int)neighbors.size();
 }
@@ -1837 +1832 @@
                 {
                         BspInterior *interior = dynamic_cast<BspInterior *>(node);
-
                         BspNode *next;
-
-                        PolygonContainer geom;
+                        BspNodeGeometry geom;
 
                         // todo: not very efficient: constructs full cell everytime
                         ConstructGeometry(interior, geom);
 
-                        const int cf = Polygon3::ClassifyPlane(geom, halfspace, mEpsilon);
+                        const int cf = 
+                                Polygon3::ClassifyPlane(geom.mPolys, halfspace, mEpsilon);
 
                         if (cf == Polygon3::BACK_SIDE)
@@ -2248 +2242 @@
 
 
-int VspBspTree::CollectMergeCandidates()
-{
-        vector<BspLeaf *> leaves;
-
-        // collect the leaves, e.g., the "voxels" that will build the view cells
-        CollectLeaves(leaves);
+int VspBspTree::CollectMergeCandidates(const vector<BspLeaf *> leaves)
+{
         BspLeaf::NewMail();
 
@@ -2291 +2281 @@
         vector<BspRay *> bspRays;
 
+        long startTime = GetTime();
         ConstructBspRays(bspRays, rays);
+        Debug << (int)bspRays.size() << " bsp rays constructed in " << TimeDiff(startTime, GetTime()) * 1e-3f << " secs" << endl;
+
         map<BspLeaf *, vector<BspLeaf*> > neighborMap;
-
         vector<BspIntersection>::const_iterator iit;
 
-        int leaves = 0;
+        int numLeaves = 0;
         
         BspLeaf::NewMail();
@@ -2321 +2313 @@
                                 leaf->mArea * leaf->mPvs->GetSize();
                         
-                        ++ leaves;
+                        ++ numLeaves;
                 }
                 
@@ -2345 +2337 @@
                                         leaf->mArea * leaf->mPvs->GetSize();
 
-                                ++ leaves;
+                                ++ numLeaves;
                         }
                 
@@ -2379 +2371 @@
         Debug << "neighbormap size: " << (int)neighborMap.size() << endl;
         Debug << "mergequeue: " << (int)mMergeQueue.size() << endl;
-        Debug << "leaves in queue: " << leaves << endl;
+        Debug << "leaves in queue: " << numLeaves << endl;
         Debug << "overall cost: " << BspMergeCandidate::sOverallCost << endl;
 
         CLEAR_CONTAINER(bspRays);
 
-        return leaves;
+        //-- collect the leaves which haven't been found by ray casting
+        vector<BspLeaf *> leaves;
+        CollectLeaves(leaves, true, mMaxPvs);
+        Debug << "found " << (int)leaves.size() << " new leaves" << endl;
+        //CollectMergeCandidates(leaves);
+
+        return numLeaves;
 }
 
@@ -2440 +2438 @@
                 mergeStats.nodes = CollectMergeCandidates(rays);
         else
-                mergeStats.nodes = CollectMergeCandidates();
+        {
+                vector<BspLeaf *> leaves;
+                CollectLeaves(leaves);
+                mergeStats.nodes = CollectMergeCandidates(leaves);
+        }
 
         mergeStats.collectTime = TimeDiff(startTime, GetTime());
@@ -2735 +2737 @@
 }
 
+#define USE_ASCII 0
+bool VspBspTree::WriteVspBspTree()
+{
+        char fileName[100];
+        environment->GetStringValue("VspBspTree.viewCellsFilename", fileName);
+        
+        /*VssRayContainer::const_iterator it, it_end = samples.end();
+        
+#if USE_ASCII
+        ofstream samplesOut(fileName);
+        if (!samplesOut.is_open())
+                return false;
+
+        for (it = samples.begin(); it != it_end; ++ it)
+        {
+                VssRay *ray = *it;
+                int sourceid = ray->mOriginObject ? ray->mOriginObject->mId : -1;               
+                int termid = ray->mTerminationObject ? ray->mTerminationObject->mId : -1;       
+
+                samplesOut << ray->GetOrigin().x << " " << ray->GetOrigin().y << " " << ray->GetOrigin().z << " " 
+                                   << ray->GetTermination().x << " " << ray->GetTermination().y << " " << ray->GetTermination().z << " " 
+                                   << sourceid << " " << termid << "\n";
+        }
+#else
+        ofstream samplesOut(fileName, ios::binary);
+        if (!samplesOut.is_open())
+                return false;
+
+        for (it = samples.begin(); it != it_end; ++ it)
+        {       
+                VssRay *ray = *it;
+                Vector3 origin(ray->GetOrigin());
+                Vector3 termination(ray->GetTermination());
+                
+                int sourceid = ray->mOriginObject ? ray->mOriginObject->mId : -1;               
+                int termid = ray->mTerminationObject ? ray->mTerminationObject->mId : -1;               
+
+                samplesOut.write(reinterpret_cast<char *>(&origin), sizeof(Vector3));
+                samplesOut.write(reinterpret_cast<char *>(&termination), sizeof(Vector3));
+                samplesOut.write(reinterpret_cast<char *>(&sourceid), sizeof(int));
+                samplesOut.write(reinterpret_cast<char *>(&termid), sizeof(int));
+    }
+#endif
+
+        samplesOut.close();
+        */
+        return true;
+}
+
+bool VspBspTree::LoadVspBspTree()
+{
+        /*std::stable_sort(objects.begin(), objects.end(), ilt);
+        char fileName[100];
+        environment->GetStringValue("Preprocessor.samplesFilename", fileName);
+        
+    Vector3 origin, termination;
+        // HACK: needed only for lower_bound algorithm to find the 
+        // intersected objects
+        MeshInstance sObj(NULL);
+        MeshInstance tObj(NULL);
+
+#if USE_ASCII
+        ifstream samplesIn(fileName, ios::binary);
+        if (!samplesIn.is_open())
+                return false;
+
+        string buf;
+        while (!(getline(samplesIn, buf)).eof())
+        {
+                sscanf(buf.c_str(), "%f %f %f %f %f %f %d %d", 
+                           &origin.x, &origin.y, &origin.z,
+                           &termination.x, &termination.y, &termination.z, 
+                           &(sObj.mId), &(tObj.mId));
+                
+                Intersectable *sourceObj = NULL;
+                Intersectable *termObj = NULL;
+                
+                if (sObj.mId >= 0)
+                {
+                        ObjectContainer::iterator oit =
+                                lower_bound(objects.begin(), objects.end(), &sObj, ilt);
+                        sourceObj = *oit;
+                }
+                
+                if (tObj.mId >= 0)
+                {
+                        ObjectContainer::iterator oit =
+                                lower_bound(objects.begin(), objects.end(), &tObj, ilt);
+                        termObj = *oit;
+                }
+
+                samples.push_back(new VssRay(origin, termination, sourceObj, termObj));
+        }
+#else
+        ifstream samplesIn(fileName, ios::binary);
+        if (!samplesIn.is_open())
+                return false;
+
+        while (1)
+        {
+                 samplesIn.read(reinterpret_cast<char *>(&origin), sizeof(Vector3));
+                 samplesIn.read(reinterpret_cast<char *>(&termination), sizeof(Vector3));
+                 samplesIn.read(reinterpret_cast<char *>(&(sObj.mId)), sizeof(int));
+                 samplesIn.read(reinterpret_cast<char *>(&(tObj.mId)), sizeof(int));
+                
+                 if (samplesIn.eof())
+                        break;
+
+                Intersectable *sourceObj = NULL;
+                Intersectable *termObj = NULL;
+                
+                if (sObj.mId >= 0)
+                {
+                        ObjectContainer::iterator oit =
+                                lower_bound(objects.begin(), objects.end(), &sObj, ilt);
+                        sourceObj = *oit;
+                }
+                
+                if (tObj.mId >= 0)
+                {
+                        ObjectContainer::iterator oit =
+                                lower_bound(objects.begin(), objects.end(), &tObj, ilt);
+                        termObj = *oit;
+                }
+
+                samples.push_back(new VssRay(origin, termination, sourceObj, termObj));
+        }
+
+#endif
+        samplesIn.close();
+*/
+        return true;
+}
+
 
 /************************************************************************/