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

Timestamp:

03/16/06 15:04:03 (19 years ago)

Author:

mattausch

Message:

implemented first version of the visibility filter

File:

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

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

@@ -544 +544 @@
 }
 
-/*
-int ViewCellsManager::ConstructLocalMergeTree(vector<LocalMergeCandidate> candidates)
-                                                                                         
-{
-        while(!candidates.empty())
-        {
-                MergeCandidate mc = candidates.back();
-                candidates.pop_back();
-                EvalMergeCost(mc);
-                mergeQueue.push(mc);
-        }
-
-        ViewCell::NewMail();
-
-        
-        long startTime = GetTime();
-
-        mergeStats.candidates = (int)mMergeQueue.size();
-
-        // passes are needed for statistics, because we don't want to record
-        // every merge
-        int pass = 0;
-        int mergedPerPass = 0;
-        float realExpectedCost = mExpectedCost;
-        float realAvgRenderCost = mAvgRenderCost;
-        int realNumActiveViewCells = mNumActiveViewCells;
-        
-         reset.
-
-        int numMergedViewCells = 0;
-
-        environment->GetIntValue("ViewCells.PostProcess.maxMergesPerPass", maxMergesPerPass);
-        environment->GetFloatValue("ViewCells.PostProcess.avgCostMaxDeviation", avgCostMaxDeviation);
-
-        cout << "actual merge starts now ... " << endl;
-
+
+inline float EvalMergeCost(ViewCell *root, ViewCell *candidate)
+{
+        return root->GetPvs().GetPvsHomogenity(candidate->GetPvs());
+}
+
+
+int GetBestViewCellIdx(ViewCell *root, const ViewCellContainer &neighborhood)
+{
+        int bestViewCellIdx = -1;;
+
+        float mergeCost = Limits::Infinity;
+        int i = 0;
+
+        ViewCellContainer::const_iterator it, it_end = neighborhood.end();
+
+        for (it = neighborhood.begin(); it != it_end; ++ it, ++ i)
+        {
+                const float mc = EvalMergeCost(root, *it);
+
+                if (mc > mergeCost)
+                {
+                        mergeCost = mc;
+                        bestViewCellIdx = i;
+                }
+        }
+
+        return bestViewCellIdx;
+}
+
+
+ViewCell *ViewCellsManager::ConstructLocalMergeTree(ViewCell *currentViewCell, 
+                                                                                                        const ViewCellContainer &viewCells)
+{
+        ViewCell *root = currentViewCell;
+        ViewCellContainer neighborhood = viewCells;
+
+        ViewCellContainer::const_iterator it, it_end = neighborhood.end();
+
+        const int n = min(mMaxFilterSize, (int)neighborhood.size());
         //-- use priority queue to merge leaf pairs
 
+
         //const float maxAvgCost = 350;
-        while (!mMergeQueue.empty())//NumActiveViewCells > mMergeMinViewCells))
-        {
-                //-- reset merge queue if the ratio of current expected cost / real expected cost
-                //   too small or after a given number of merges
-                if ((mergedPerPass > maxMergesPerPass) ||
-                        (avgCostMaxDeviation > mAvgRenderCost / realAvgRenderCost))
-                {
-                        // adjust render cost
-                        ++ pass;
-
-                        mergedPerPass = 0;
-                        mExpectedCost = realExpectedCost;
-                                        
-                        
+        for (int nMergedViewCells = 0; nMergedViewCells < n; ++ nMergedViewCells)
+        {
+                const int bestViewCellIdx = GetBestViewCellIdx(root, neighborhood);
                 
-                        // refines the view cells
-                        // then priorities are recomputed
-                        // and the candidates are put back into merge queue
-                        if (mRefineViewCells)
-                                RefineViewCells(rays, objects);
-                        else
-                                ResetMergeQueue();
-
-                        Debug << "Values after reset: "  
-                                  << " erc: " << mExpectedCost 
-                                  << " avg: " << mAvgRenderCost 
-                                  << " dev: " << mDeviation << endl;
-
-                        if (mExportMergedViewCells)
-                        {
-                                ExportMergedViewCells(activeViewCells, objects, numMergedViewCells);
-                        }
-                }
-
-
-                MergeCandidate mc = mMergeQueue.top();
-                mMergeQueue.pop();
-        
-                // both view cells equal
-                // NOTE: do I really still need this? probably cannot happen!!
-                if (mc.mLeftViewCell == mc.mRightViewCell)
-                        continue;
-
-                if (mc.IsValid())
-                {
-                        ViewCell::NewMail();
-
-                        //-- update statistical values
-                        -- realNumActiveViewCells;
-                        ++ mergeStats.merged;
-                        ++ mergedPerPass;
-
-                        const float renderCostIncr = mc.GetRenderCost();
-                        const float mergeCostIncr = mc.GetMergeCost();
-
-                        totalRenderCost += renderCostIncr;
-                        mDeviation += mc.GetDeviationIncr();
-                        
-                        
-                        // merge the view cells of leaf1 and leaf2
-                        int pvsDiff;
-                        ViewCellInterior *mergedVc = 
-                                MergeViewCells(mc.mLeftViewCell, mc.mRightViewCell, pvsDiff);
-
-
-                        // total render cost and deviation has changed
-                        // real expected cost will be larger than expected cost used for the
-                        // cost heuristics, but cannot recompute costs on each increase of the 
-                        // expected cost
-                        totalPvs += pvsDiff;
-                        realExpectedCost = totalRenderCost / (float)realNumActiveViewCells;
-                        realAvgRenderCost = (float)totalPvs / (float)realNumActiveViewCells;
-        
-                        // set merge cost to this node
-                        mergedVc->SetMergeCost(totalRenderCost);
-
-                        //if (mViewCellsManager->EqualToSpatialNode(mergedVc))
-                        //      ++ mergeStats.siblings;
-                        mergedVc->SetCost(realExpectedCost);
-
-                        if ((mergeStats.merged % statsOut) == 0)
-                                cout << "merged " << mergeStats.merged << " view cells" << endl;
-
-                }
-                else
-                { 
-                        // merge candidate not valid, because one of the leaves was already
-                        // merged with another one => validate and reinsert into queue
-                        if (ValidateMergeCandidate(mc))
-                        {
-                                EvalMergeCost(mc);
-                                mMergeQueue.push(mc);
-                        }
-                }
+                ViewCell *bestViewCell = neighborhood[bestViewCellIdx];
                 
-        }
-
-        
-        // adjust stats and reset queue one final time
-        mExpectedCost = realExpectedCost;
-        mAvgRenderCost = realAvgRenderCost;
-        mNumActiveViewCells = realNumActiveViewCells;
-
-        UpdateActiveViewCells(activeViewCells);
-
-        
-        // refine view cells and reset costs
-        if (mRefineViewCells)
-                RefineViewCells(rays, objects);
-        else
-                ResetMergeQueue();
-
-        // create a root node if the merge was not done till root level,
-        // else take the single node as new root
-        if ((int)activeViewCells.size() > 1)
-        {
-                Debug << "creating root of view cell hierarchy for " 
-                          << (int)activeViewCells.size() << " view cells" << endl;
+                // remove from vector
+                swap(neighborhood[bestViewCellIdx], neighborhood.back());
+                neighborhood.pop_back();
                 
-                ViewCellInterior *root = mViewCellsManager->MergeViewCells(activeViewCells);
-                root->SetMergeCost(totalRenderCost);
-                // $$JB keep this 0 temporarilly
-                root->SetCost(0.0f);
-
-                mRoot = root;
-        }
-        else if ((int)activeViewCells.size() == 1)
-        {
-                Debug << "setting root of the merge history" << endl;
-                mRoot = activeViewCells[0];
-        }
-
-        //-- empty merge queue just in case
-        while (!mMergeQueue.empty())
-        {
-                mMergeQueue.pop();
-        }
-
-        // TODO delete because makes no sense here
-        mergeStats.expectedRenderCost = realExpectedCost;
-        mergeStats.deviation = mDeviation;
-
-        // we want to optimize this heuristics
-        mergeStats.heuristics = 
-                mDeviation * (1.0f - mRenderCostWeight) + 
-                mExpectedCost * mRenderCostWeight;
-
-        mergeStats.mergeTime = TimeDiff(startTime, GetTime());
-        mergeStats.Stop();
-        Debug << mergeStats << endl << endl;
-
-        // assign colors for the view cells so that at least one is always consistent
-        AssignRandomColors();
-        
-        //TODO: should return sample contributions?
-        return mergeStats.merged;
-}
-*/
+                if (!bestViewCell || !root)
+                        cout << "warning!!" << endl;
+                // create new root of the hierarchy
+                root = MergeViewCells(root, bestViewCell);
+        }
+
+        return root;    
+}
+
 
 bool ViewCellsManager::CheckValidity(ViewCell *vc,
@@ -771 +637 @@
         const AxisAlignedBox3 box = GetFilterBBox(viewPoint, mFilterWidth);
 
+        ViewCell *currentViewCell = GetViewCell(viewPoint);
+
         ViewCellContainer viewCells;
         ComputeBoxIntersections(box, viewCells);
 
-                
+        ViewCell *root = ConstructLocalMergeTree(currentViewCell, viewCells);
+
+        prvs.mViewCell = root;
+        //prvs.mPvs = root->GetPvs();
 }
 
@@ -2050 +1921 @@
                 subdivVol += (*it)->GetVolume();
 
-                float thres = 0.9;
+                float thres = 0.9f;
                 if ((lVol < ((*it)->GetVolume() * thres)) ||
                         (lVol * thres > ((*it)->GetVolume())))
@@ -4106 +3977 @@
                 subdivVol += (*it)->GetVolume();
                 
-                float thres = 0.9;
+                float thres = 0.9f;
                 if ((lVol < ((*it)->GetVolume() * thres)) || (lVol * thres > ((*it)->GetVolume())))
                         Debug << "warning: " << lVol << " " << (*it)->GetVolume() << endl;
@@ -4129 +4000 @@
         Exporter *exporter = Exporter::GetExporter("filter.x3d");
 
+        Vector3 bsize = mViewSpaceBox.Size();
+        const Vector3 viewPoint(mViewSpaceBox.Center());
+        const Vector3 width = Vector3(mFilterWidth);
+        
+        PrVs testPrVs;
+        
         if (exporter)
         {
-                AxisAlignedBox3 testBox = mViewSpaceBox;
-                Vector3 bsize = mViewSpaceBox.Size();
-
-                testBox.Enlarge(Vector3(-bsize[0] * 0.3, 0, -bsize[2] * 0.4));
-                
                 ViewCellContainer viewCells;
-        
-                mVspBspTree->ComputeBoxIntersections(testBox, viewCells);
-                cout << "view cells: " << viewCells.size() << endl;
-                
+        
+        const AxisAlignedBox3 tbox = GetFilterBBox(viewPoint, mFilterWidth);
+
+                GetPrVS(viewPoint, testPrVs);
+
                 exporter->SetWireframe();
 
                 exporter->SetForcedMaterial(RgbColor(1,1,1));
-                exporter->ExportBox(testBox);
+                exporter->ExportBox(tbox);
                 
                 exporter->SetFilled();
                 exporter->ResetForcedMaterial();
-        for (int i = 0; i < viewCells.size(); ++ i)
-                {
-                        BspNodeGeometry geom;
-                                
-                        mVspBspTree->ConstructGeometry(viewCells[i], geom);
-                        exporter->ExportPolygons(geom.GetPolys());
-                }               
-
-                exporter->SetForcedMaterial(RgbColor(1,0,0));
+
+                ExportViewCellGeometry(exporter, testPrVs.mViewCell);
+
+        exporter->SetForcedMaterial(RgbColor(1,0,0));
                 exporter->ExportGeometry(objects);