Ignore:
Timestamp:
03/09/07 18:30:24 (18 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/Lib/Vis/Preprocessing/src
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/Preprocessing/src/BvHierarchy.cpp

    r2210 r2224  
    393393        mNodeTimer.Entry(); 
    394394 
    395 /* 
    396 #if STORE_VIEWCELLS_WITH_BVH 
    397         AssociateViewCellsWithObjects(sc.mSampledFrontObjects); 
    398         AssociateViewCellsWithObjects(sc.mSampledBackObjects); 
    399 #endif   
    400 */ 
    401395        const BvhTraversalData &tData = sc.mParentData; 
    402396        BvhLeaf *leaf = tData.mNode; 
    … …  
    500494                AssignSortedObjects(sc, frontData, backData); 
    501495        } 
    502 /* 
    503 #if STORE_VIEWCELLS_WITH_BVH 
    504         ReleaseViewCells(sc.mSampledFrontObjects); 
    505         ReleaseViewCells(sc.mSampledBackObjects); 
    506 #endif 
    507 */ 
     496 
    508497        mNodeTimer.Exit(); 
    509498 
    … …  
    515504BvhNode *BvHierarchy::Subdivide(SplitQueue &tQueue, 
    516505                                                                SubdivisionCandidate *splitCandidate, 
    517                                                                 const bool globalCriteriaMet) 
     506                                                                const bool globalCriteriaMet 
     507                                                                ,vector<SubdivisionCandidate *> &dirtyList 
     508                                                                ) 
    518509{ 
    519510        mSubdivTimer.Entry(); 
    … …  
    552543                                new BvhSubdivisionCandidate(tBackData); 
    553544                 
    554                 EvalSubdivisionCandidate(*frontCandidate); 
    555                 EvalSubdivisionCandidate(*backCandidate); 
    556  
     545                // preprocess view cells 
     546                AssociateViewCellsWithObjects(*tData.mSampledObjects); 
     547 
     548                EvalSubdivisionCandidate(*frontCandidate, true, false); 
     549                EvalSubdivisionCandidate(*backCandidate, true, false); 
     550 
     551                CollectDirtyCandidates(sc, dirtyList, true); 
     552                ReleaseViewCells(*tData.mSampledObjects); 
     553                 
    557554                // cross reference 
    558555                tFrontData.mNode->SetSubdivisionCandidate(frontCandidate);  
    … …  
    638635 
    639636void BvHierarchy::EvalSubdivisionCandidate(BvhSubdivisionCandidate &splitCandidate,  
    640                                                                                    bool computeSplitPlane) 
     637                                                                                   const bool computeSplitPlane, 
     638                                                                                   const bool preprocessViewCells) 
    641639{ 
    642640        mPlaneTimer.Entry(); 
    643641 
    644642#if STORE_VIEWCELLS_WITH_BVH 
    645         // fill view cells cache 
    646         AssociateViewCellsWithObjects(*splitCandidate.mParentData.mSampledObjects); 
     643        if (preprocessViewCells) // fill view cells cache 
     644                AssociateViewCellsWithObjects(*splitCandidate.mParentData.mSampledObjects); 
    647645#endif 
    648646 
    … …  
    656654                const bool sufficientSamples =  
    657655                        splitCandidate.mParentData.mNumRays > mMinRaysForVisibility; 
     656 
     657                //if (!sufficientSamples) cout << splitCandidate.mParentData.mNumRays << " "; 
    658658 
    659659                const bool useVisibiliyBasedHeuristics =  
    … …  
    757757 
    758758#if STORE_VIEWCELLS_WITH_BVH 
    759         ReleaseViewCells(*splitCandidate.mParentData.mSampledObjects); 
     759        if (preprocessViewCells) 
     760                ReleaseViewCells(*splitCandidate.mParentData.mSampledObjects); 
    760761#endif 
    761762 
    … …  
    16721673        VssRay::NewMail(); 
    16731674 
    1674         if ((mMaxTests < tData.mNumRays) &&      mUseCostHeuristics && useVisibilityBasedHeuristics) 
     1675        /*if ((mMaxTests < tData.mNumRays) && mUseCostHeuristics && useVisibilityBasedHeuristics) 
    16751676        { 
    16761677                VssRayContainer rays; 
    … …  
    16921693                        } 
    16931694                }                
    1694         } 
     1695        }*/ 
    16951696 
    16961697        //////////////////////////////////// 
    … …  
    17331734                        } 
    17341735 
    1735                         // no good results for degenerate axis split 
     1736                        // avoid splits in degenerate axis with high penalty 
    17361737                        if (1 && 
    17371738                                (tData.mNode->GetBoundingBox().Size(axis) < 0.0001))//Limits::Small)) 
    … …  
    24052406        /////////////////////////////////////// 
    24062407        // start from root of tree 
    2407         /* 
     2408 
    24082409        if (node == NULL) 
    24092410                node = mRoot; 
    … …  
    24492450   
    24502451        return leaf; 
    2451         */ 
    24522452} 
    24532453#endif 
    … …  
    26322632                 
    26332633                // evaluate priority 
    2634                 EvalSubdivisionCandidate(*oSubdivisionCandidate); 
     2634                EvalSubdivisionCandidate(*oSubdivisionCandidate, true, true); 
    26352635                PrintSubdivisionStats(*oSubdivisionCandidate); 
    26362636 
    … …  
    26462646                         
    26472647                        // reevaluate priority 
    2648                         EvalSubdivisionCandidate(*sCandidate); 
     2648                        EvalSubdivisionCandidate(*sCandidate, true, true); 
    26492649                        tQueue.Push(sCandidate); 
    26502650                } 
    … …  
    26552655        {        
    26562656                // evaluate priority 
    2657                 EvalSubdivisionCandidate(*oSubdivisionCandidate); 
     2657                EvalSubdivisionCandidate(*oSubdivisionCandidate, true, true); 
    26582658                PrintSubdivisionStats(*oSubdivisionCandidate); 
    26592659 
    … …  
    27942794                new BvhSubdivisionCandidate(oData); 
    27952795 
    2796         EvalSubdivisionCandidate(*oSubdivisionCandidate); 
     2796        EvalSubdivisionCandidate(*oSubdivisionCandidate, true, true); 
    27972797        bvhLeaf->SetSubdivisionCandidate(oSubdivisionCandidate); 
    27982798 
    … …  
    29292929                 
    29302930                // evaluate the changes in render cost and pvs entries 
    2931                 EvalSubdivisionCandidate(*sc, false); 
     2931                EvalSubdivisionCandidate(*sc, false, true); 
    29322932 
    29332933                // create new interior node and two leaf node 
    … …  
    30623062                        const bool globalCriteriaMet = GlobalTerminationCriteriaMet(bsc->mParentData); 
    30633063                 
    3064                         BvhNode *node = Subdivide(tempQueue, bsc, globalCriteriaMet); 
     3064                        SubdivisionCandidateContainer dirtyList; 
     3065                        BvhNode *node = Subdivide(tempQueue, bsc, globalCriteriaMet, dirtyList); 
    30653066 
    30663067                        // not needed anymore 

  • GTP/trunk/Lib/Vis/Preprocessing/src/BvHierarchy.h

    r2210 r2224  
    471471                { 
    472472            mDirty = false; 
    473                         sBvHierarchy->EvalSubdivisionCandidate(*this, computeSplitplane); 
     473                        sBvHierarchy->EvalSubdivisionCandidate(*this, computeSplitplane, true); 
    474474                } 
    475475 
    476                 bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet) 
     476                bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet, SubdivisionCandidateContainer &dirtyList) 
    477477                { 
    478                         BvhNode *n = sBvHierarchy->Subdivide(splitQueue, this, terminationCriteriaMet); 
     478                        BvhNode *n = sBvHierarchy->Subdivide(splitQueue, this, terminationCriteriaMet, dirtyList); 
    479479 
    480480                        // local or global termination criteria failed 
    … …  
    575575        /** Evaluates candidate for splitting. 
    576576        */ 
    577         void EvalSubdivisionCandidate(BvhSubdivisionCandidate &splitData,  
    578                                                                   bool computeSplitPlane = true); 
     577        void EvalSubdivisionCandidate(BvhSubdivisionCandidate &splitData, 
     578                                                                  const bool computeSplitPlane, 
     579                                                                  const bool preprocessViewCells); 
    579580 
    580581        /** Returns vector of leaves. 
    … …  
    754755        BvhNode *Subdivide(SplitQueue &tQueue,  
    755756                                           SubdivisionCandidate *splitCandidate, 
    756                                            const bool globalCriteriaMet); 
     757                                           const bool globalCriteriaMet 
     758                                           ,vector<SubdivisionCandidate *> &dirtyList 
     759                                           ); 
    757760         
    758761        /** Subdivides leaf. 

  • GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.cpp

    r2210 r2224  
    837837                return childPvs; 
    838838        } 
     839 
    839840        // assume pvs not sampled sufficiently => take total pvs 
    840841        if (avgRayContri >= mMaxAvgRayContri) 
    … …  
    852853        const float newPvs = alpha * childPvs + (1.0f - alpha) * totalPvs; 
    853854#endif 
    854  
     855cout<<"a"; 
    855856        //cout << "alpha " << alpha << " beta: " << beta << " child: " << childPvs << " parent: " << totalPvs << endl; 
    856857         
    … …  
    863864bool HierarchyManager::ApplySubdivisionCandidate(SubdivisionCandidate *sc,  
    864865                                                                                                 SplitQueue &splitQueue, 
    865                                                                                                  const bool repairQueue) 
     866                                                                                                 //const bool repairQueue, 
     867                                                                                                 SubdivisionCandidateContainer &dirtyList) 
    866868{ 
    867869        const bool terminationCriteriaMet = GlobalTerminationCriteriaMet(sc); 
    868         const bool success = sc->Apply(splitQueue, terminationCriteriaMet); 
     870        const bool success = sc->Apply(splitQueue, terminationCriteriaMet, dirtyList); 
    869871 
    870872        if (sc->IsDirty()) 
    … …  
    934936        // output stats 
    935937        EvalSubdivisionStats(); 
    936                  
    937         if (repairQueue)  
    938         { 
    939                 // reevaluate candidates affected by the split for view space splits,  
    940                 // this would be object space splits and other way round 
    941                 vector<SubdivisionCandidate *> dirtyList; 
    942                 sc->CollectDirtyCandidates(dirtyList, false); 
    943  
    944                 RepairQueue(dirtyList, splitQueue, mRecomputeSplitPlaneOnRepair); 
    945         } 
    946938 
    947939        return true; 
    … …  
    10461038                                                                           AxisAlignedBox3 *forcedViewSpace) 
    10471039{ 
     1040        SubdivisionCandidate::NewMail(); 
     1041 
    10481042        while (!FinishedConstruction()) 
    10491043        { 
    … …  
    10531047                //-- subdivide leaf node 
    10541048 
    1055                 ApplySubdivisionCandidate(sc, mTQueue, repairQueue); 
     1049                SubdivisionCandidateContainer dirtyList; 
     1050 
     1051                ApplySubdivisionCandidate(sc, mTQueue, dirtyList); 
    10561052                                 
     1053                if (repairQueue)  
     1054                { 
     1055                        // reevaluate candidates affected by the split for view space splits,  
     1056                        // this would be object space splits and other way round 
     1057                        RepairQueue(dirtyList, mTQueue, mRecomputeSplitPlaneOnRepair); 
     1058                }        
     1059 
    10571060                // we use objects for evaluating vsp tree construction until  
    10581061                // a certain depth once a certain depth existiert ... 
    … …  
    11031106                //-- subdivide leaf node of either type 
    11041107 
    1105         ApplySubdivisionCandidate(sc, mTQueue, repairQueue); 
     1108                SubdivisionCandidateContainer dirtyList; 
     1109        ApplySubdivisionCandidate(sc, mTQueue, dirtyList); 
    11061110                 
     1111                if (repairQueue) 
     1112                { 
     1113                        RepairQueue(dirtyList, mTQueue, mRecomputeSplitPlaneOnRepair); 
     1114                } 
     1115 
    11071116                DEL_PTR(sc); 
    11081117        } 
    … …  
    11401149                SubdivisionCandidate *sc = NextSubdivisionCandidate(splitQueue);  
    11411150                         
    1142                 const bool repairQueue = false; 
    1143                 const bool success = ApplySubdivisionCandidate(sc, splitQueue, repairQueue); 
     1151                const bool success = ApplySubdivisionCandidate(sc, splitQueue, dirtyCandidates); 
    11441152 
    11451153                if (success) 
    11461154                { 
    1147                         sc->CollectDirtyCandidates(dirtyCandidates, true); 
     1155                        //sc->CollectDirtyCandidates(dirtyCandidates, true); 
    11481156                        ++ steps; 
    11491157                } 

  • GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.h

    r2187 r2224  
    377377        bool ApplySubdivisionCandidate(SubdivisionCandidate *sc,  
    378378                                                                   SplitQueue &splitQueue, 
    379                                                                    const bool repairQueue); 
     379                                                                   //const bool repairQueue, 
     380                                                                   std::vector<SubdivisionCandidate *> &dirtyList 
     381                                                                   ); 
    380382 
    381383        /** Tests if hierarchy construction is finished. 

  • GTP/trunk/Lib/Vis/Preprocessing/src/OspTree.h

    r2176 r2224  
    264264                } 
    265265 
    266                 bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet) 
     266                bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet, SubdivisionCandidateContainer &dirtyList) 
    267267                { 
    268268                        KdNode *n = sOspTree->Subdivide(splitQueue ,this,  terminationCriteriaMet); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/SubdivisionCandidate.h

    r2176 r2224  
    4040        /** Evaluate this candidate and put results into queue for further traversal. 
    4141        */ 
    42         virtual bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet) = 0; 
     42        virtual bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet, SubdivisionCandidateContainer &dirtyList) = 0; 
    4343         
    4444        /** Returns true of the global termination criteria of this split were met, 

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

    r2206 r2224  
    118118         
    119119        mStats << 
    120                 "#Pass\n" << pass ++ << endl << 
    121                 "#Time\n" << time << endl << 
    122                 "#TotalSamples\n" << totalRays << endl; 
    123  
    124         float last = 0.0f; 
    125  
    126         for (int k=0; k < 6; ++ k)  
    127         { 
    128                 float ratio = 0.0f; 
    129  
    130                 if (k < (int)mMixtureDistribution->mDistributions.size())  
    131                 { 
    132                         ratio = mMixtureDistribution->mDistributions[k]->mRatio - last; 
    133                         last = mMixtureDistribution->mDistributions[k]->mRatio; 
    134                 } 
    135  
    136                 mStats <<  "#Distribution"<<k<<endl<< ratio<<endl; 
    137         } 
     120                "#Pass\n" << pass ++ <<endl<< 
     121                "#Time\n" << time <<endl<< 
     122                "#TotalSamples\n" <<totalRays<<endl; 
    138123         
    139124 
    … …  
    187172        else 
    188173        { 
    189                 /*mStrategies.push_back(SamplingStrategy::OBJECT_BASED_DISTRIBUTION); 
    190                 mStrategies.push_back(SamplingStrategy::REVERSE_VIEWSPACE_BORDER_BASED_DISTRIBUTION); 
     174                mStrategies.push_back(SamplingStrategy::OBJECT_BASED_DISTRIBUTION); 
     175                //mStrategies.push_back(SamplingStrategy::REVERSE_VIEWSPACE_BORDER_BASED_DISTRIBUTION); 
    191176                mStrategies.push_back(SamplingStrategy::REVERSE_OBJECT_BASED_DISTRIBUTION); 
    192                 */ 
    193          
     177                         
    194178                mStrategies.push_back(SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION); 
    195179        } 
    … …  
    23792363void ViewCellsManager::UpdatePvs() 
    23802364{ 
    2381   if (mViewCellPvsIsUpdated || !ViewCellsTreeConstructed()) 
    2382         return; 
    2383    
    2384   mViewCellPvsIsUpdated = true; 
    2385    
    2386   ViewCellContainer leaves; 
    2387   mViewCellsTree->CollectLeaves(mViewCellsTree->GetRoot(), leaves); 
    2388    
    2389   ViewCellContainer::const_iterator it, it_end = leaves.end(); 
    2390    
    2391   for (it = leaves.begin(); it != it_end; ++ it) 
    2392         { 
    2393           mViewCellsTree->PropagatePvs(*it); 
     2365        if (mViewCellPvsIsUpdated || !ViewCellsTreeConstructed()) 
     2366                return; 
     2367 
     2368        mViewCellPvsIsUpdated = true; 
     2369 
     2370        ViewCellContainer leaves; 
     2371        mViewCellsTree->CollectLeaves(mViewCellsTree->GetRoot(), leaves); 
     2372 
     2373        ViewCellContainer::const_iterator it, it_end = leaves.end(); 
     2374 
     2375        for (it = leaves.begin(); it != it_end; ++ it) 
     2376        { 
     2377                mViewCellsTree->PropagatePvs(*it); 
    23942378        } 
    23952379} 
    … …  
    23992383{ 
    24002384  // update pvs of view cells tree if necessary 
    2401   UpdatePvs(); 
     2385  if (0) UpdatePvs(); 
    24022386   
    24032387  ViewCellContainer::const_iterator it = mViewCells.begin(); 
    … …  
    24162400  stat.devRelPvsIncrease = 0.0f; 
    24172401  stat.renderCost = 0.0f; 
     2402  stat.mem = 0.0f; 
    24182403 
    24192404  if (mPerViewCellStat.size() != mViewCells.size()) { 
    … …  
    24312416  const float vol = mViewSpaceBox.GetVolume(); 
    24322417 
    2433   for (i=0; it != mViewCells.end(); ++ it, i++)  
    2434         { 
     2418  for (i = 0; it != mViewCells.end(); ++ it, ++ i)  
     2419  { 
    24352420          ViewCell *viewcell = *it; 
    24362421          if (viewcell->GetValid()) { 
    2437                 const float pvsCost = mViewCellsTree->GetPvsCost(viewcell); 
    2438                 const float renderCost = pvsCost * viewcell->GetVolume() / vol; 
    2439  
    2440                 if (pvsCost < stat.minPvs) 
    2441                   stat.minPvs = pvsCost; 
    2442                 if (pvsCost > stat.maxPvs) 
    2443                   stat.maxPvs = pvsCost; 
    2444                  
    2445                 stat.avgPvs += pvsCost; 
    2446                 stat.renderCost += renderCost; 
    2447  
    2448                 const float pvsEntries = (float)mViewCellsTree->GetPvsEntries(viewcell); 
    2449                 stat.avgPvsEntries += pvsEntries; 
    2450                  
    2451                 if (mPerViewCellStat[i].pvsSize > 0.0f) 
    2452                   mPerViewCellStat[i].relPvsIncrease = (pvsCost - mPerViewCellStat[i].pvsSize)/mPerViewCellStat[i].pvsSize; 
    2453                  
    2454                 stat.avgRelPvsIncrease += mPerViewCellStat[i].relPvsIncrease; 
    2455                  
    2456                 // update the pvs size 
    2457                 mPerViewCellStat[i].pvsSize = pvsCost; 
    2458                  
    2459                  
    2460                  
    2461                 if (evaluateFilter) { 
    2462                   ObjectPvs filteredPvs; 
    2463                    
    2464                   PvsFilterStatistics fstat = ApplyFilter2(viewcell, 
    2465                                                                                                    false, 
    2466                                                                                                    mFilterWidth, 
    2467                                                                                                    filteredPvs); 
    2468                    
    2469                   float filteredCost = filteredPvs.EvalPvsCost(); 
    2470  
    2471                   stat.avgFilteredPvs += filteredCost; 
    2472                   stat.avgFilteredPvsEntries += filteredPvs.GetSize(); 
    2473                    
    2474                   stat.avgFilterContribution += filteredCost - pvsCost; 
    2475                    
    2476                   stat.avgFilterRadius += fstat.mAvgFilterRadius; 
    2477                   int sum = fstat.mGlobalFilterCount + fstat.mLocalFilterCount; 
    2478                   if (sum) { 
    2479                         stat.avgFilterRatio += fstat.mLocalFilterCount / 
    2480                           (float) sum; 
     2422                  const float pvsCost = mViewCellsTree->GetPvsCost(viewcell); 
     2423                  const float renderCost = pvsCost * viewcell->GetVolume() / vol; 
     2424 
     2425                  if (pvsCost < stat.minPvs) 
     2426                          stat.minPvs = pvsCost; 
     2427                  if (pvsCost > stat.maxPvs) 
     2428                          stat.maxPvs = pvsCost; 
     2429 
     2430                  stat.avgPvs += pvsCost; 
     2431                  stat.renderCost += renderCost; 
     2432 
     2433                  const float pvsEntries = (float)mViewCellsTree->GetPvsEntries(viewcell); 
     2434                  stat.avgPvsEntries += pvsEntries; 
     2435 
     2436                  if (mPerViewCellStat[i].pvsSize > 0.0f) 
     2437                          mPerViewCellStat[i].relPvsIncrease = (pvsCost - mPerViewCellStat[i].pvsSize) / mPerViewCellStat[i].pvsSize; 
     2438 
     2439                  stat.avgRelPvsIncrease += mPerViewCellStat[i].relPvsIncrease; 
     2440 
     2441                  // update the pvs size 
     2442                  mPerViewCellStat[i].pvsSize = pvsCost; 
     2443 
     2444 
     2445 
     2446                  if (evaluateFilter) { 
     2447                          ObjectPvs filteredPvs; 
     2448 
     2449                          PvsFilterStatistics fstat = ApplyFilter2(viewcell, 
     2450                                  false, 
     2451                                  mFilterWidth, 
     2452                                  filteredPvs); 
     2453 
     2454                          float filteredCost = filteredPvs.EvalPvsCost(); 
     2455 
     2456                          stat.avgFilteredPvs += filteredCost; 
     2457                          stat.avgFilteredPvsEntries += filteredPvs.GetSize(); 
     2458 
     2459                          stat.avgFilterContribution += filteredCost - pvsCost; 
     2460 
     2461                          stat.avgFilterRadius += fstat.mAvgFilterRadius; 
     2462                          int sum = fstat.mGlobalFilterCount + fstat.mLocalFilterCount; 
     2463                          if (sum) { 
     2464                                  stat.avgFilterRatio += fstat.mLocalFilterCount / 
     2465                                          (float) sum; 
     2466                          } 
     2467 
     2468                  } else { 
     2469                          stat.avgFilteredPvs += pvsCost; 
     2470                          stat.avgFilterContribution += 0; 
    24812471                  } 
    2482                    
    2483                 } else { 
    2484                   stat.avgFilteredPvs += pvsCost; 
    2485                   stat.avgFilterContribution += 0; 
    2486                 } 
    2487                  
    2488                 ++ stat.viewcells; 
     2472 
     2473                  ++ stat.viewcells; 
    24892474          } 
    2490         } 
    2491  
    2492    
    2493    
     2475  } 
     2476 
     2477 
     2478 
    24942479  if (stat.viewcells) { 
    2495         stat.avgPvs/=stat.viewcells; 
    2496         stat.avgPvsEntries/=stat.viewcells; 
    2497         stat.avgFilteredPvsEntries/=stat.viewcells; 
    2498         stat.avgFilteredPvs/=stat.viewcells; 
    2499         stat.avgFilterContribution/=stat.viewcells; 
    2500         stat.avgFilterRadius/=stat.viewcells; 
    2501         stat.avgFilterRatio/=stat.viewcells;  
    2502         stat.avgRelPvsIncrease/=stat.viewcells; 
    2503  
    2504         // evaluate std deviation of relPvsIncrease 
    2505         float sum=0.0f; 
    2506         for (i=0; i < stat.viewcells; i++) { 
    2507           sum += sqr(mPerViewCellStat[i].relPvsIncrease - stat.avgRelPvsIncrease); 
    2508         } 
    2509         stat.devRelPvsIncrease = sqrt(sum/stat.viewcells); 
     2480          stat.mem = (float)(ObjectPvs::GetEntrySizeByte() * stat.avgPvsEntries + stat.viewcells * 16) / float(1024 * 1024);  
     2481 
     2482          stat.avgPvs/=stat.viewcells; 
     2483          stat.avgPvsEntries/=stat.viewcells; 
     2484          stat.avgFilteredPvsEntries/=stat.viewcells; 
     2485          stat.avgFilteredPvs/=stat.viewcells; 
     2486          stat.avgFilterContribution/=stat.viewcells; 
     2487          stat.avgFilterRadius/=stat.viewcells; 
     2488          stat.avgFilterRatio/=stat.viewcells;  
     2489          stat.avgRelPvsIncrease/=stat.viewcells; 
     2490           
     2491          // evaluate std deviation of relPvsIncrease 
     2492          float sum=0.0f; 
     2493          for (i=0; i < stat.viewcells; i++) { 
     2494                  sum += sqr(mPerViewCellStat[i].relPvsIncrease - stat.avgRelPvsIncrease); 
     2495          } 
     2496          stat.devRelPvsIncrease = sqrt(sum/stat.viewcells); 
    25102497  } 
    2511    
     2498 
    25122499} 
    25132500 
    … …  
    25202507  s<<"#AVG_PVS\n"<<pvsStat.avgPvs<<endl; 
    25212508  s<<"#AVG_ENTRIES_PVS\n"<<pvsStat.avgPvsEntries<<endl; 
     2509  s<<"#RENDERCOST\n"<<pvsStat.renderCost<<endl; 
    25222510  s<<"#AVG_FILTERED_PVS\n"<<pvsStat.avgFilteredPvs<<endl; 
    25232511  s<<"#AVG_FILTERED_ENTRIES_PVS\n"<<pvsStat.avgFilteredPvsEntries<<endl; 
    … …  
    25292517  s<<"#AVG_REL_PVS_INCREASE\n"<<pvsStat.avgRelPvsIncrease<<endl; 
    25302518  s<<"#DEV_REL_PVS_INCREASE\n"<<pvsStat.devRelPvsIncrease<<endl; 
     2519  s<<"#MEMROY\n"<<pvsStat.mem<<endl; 
    25312520 
    25322521  s<<"#CONTRIBUTING_RAYS\n"<<mSamplesStat.mContributingRays<<endl; 
    … …  
    68636852    cout << "Evaluating view cell partition ... " << endl; 
    68646853 
    6865         vector<int> evalStrats; 
    6866  
    6867         // mix of sampling strategies 
    6868         if (0) 
    6869         { 
    6870                 evalStrats.push_back(SamplingStrategy::OBJECT_DIRECTION_BASED_DISTRIBUTION); 
    6871         } 
    6872         else 
    6873         { 
    6874                 /*evalStrats.push_back(SamplingStrategy::OBJECT_BASED_DISTRIBUTION); 
    6875                 evalStrats.push_back(SamplingStrategy::REVERSE_VIEWSPACE_BORDER_BASED_DISTRIBUTION); 
    6876                 evalStrats.push_back(SamplingStrategy::REVERSE_OBJECT_BASED_DISTRIBUTION); 
    6877                 */ 
    6878                 evalStrats.push_back(SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION); 
    6879         } 
    6880                          
    6881     Debug << "casting eval strategies: "; 
    6882         for (int i = 0; i < (int)evalStrats.size(); ++ i) 
    6883                 Debug << evalStrats[i] << " "; 
    6884         Debug << endl; 
    6885  
    6886         cout << "casting eval strategies: "; 
    6887         for (int i = 0; i < (int)evalStrats.size(); ++ i) 
    6888                 cout << evalStrats[i] << " "; 
    6889         cout << endl; 
    6890  
    68916854        int pass = 0; 
    68926855 
    … …  
    69056868                Debug << "casting " << samplesPerPass << " samples ... "; 
    69066869         
    6907                 if (0) 
    6908                 { 
    6909                         CastPassSamples(samplesPerPass, evalStrats, evaluationSamples); 
    6910  
    6911                         timeDiff = TimeDiff(startTime, GetTime()); 
    6912                         cout << "finished in " << timeDiff * 1e-3f << " secs" << endl; 
    6913                         Debug << "finished in " << timeDiff * 1e-3f << " secs" << endl; 
     6870                // use mixed distributions 
     6871                CastEvaluationSamples(samplesPerPass, evaluationSamples); 
     6872 
     6873                timeDiff = TimeDiff(startTime, GetTime()); 
     6874                cout << "finished in " << timeDiff * 1e-3f << " secs" << endl; 
     6875                Debug << "finished in " << timeDiff * 1e-3f << " secs" << endl; 
    69146876                 
    6915                         cout << "computing sample contributions of " << (int)evaluationSamples.size()  << " samples ... "; 
    6916                         Debug << "computing sample contributions of " << (int)evaluationSamples.size()  << " samples ... "; 
    6917  
    6918                         startTime = GetTime(); 
    6919  
    6920                         ComputeSampleContributions(evaluationSamples, true, false); 
    6921  
    6922                         timeDiff = TimeDiff(startTime, GetTime()); 
    6923                         cout << "finished in " << timeDiff * 1e-3 << " secs" << endl; 
    6924                         Debug << "finished in " << timeDiff * 1e-3 << " secs" << endl; 
    6925                 } 
    6926                 else 
    6927                 { 
    6928                         // use mixed distributions 
    6929                         CastEvaluationSamples(samplesPerPass, evaluationSamples); 
    6930  
    6931                         timeDiff = TimeDiff(startTime, GetTime()); 
    6932                         cout << "finished in " << timeDiff * 1e-3f << " secs" << endl; 
    6933                         Debug << "finished in " << timeDiff * 1e-3f << " secs" << endl; 
     6877                // don't use sample contributions because already accounted for inside the mixture distribution! 
    69346878                 
    6935                         // don't use sample contributions because already accounted for inside the mixture distribution! 
    6936                 } 
    6937  
    69386879                castSamples += samplesPerPass; 
    69396880 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.h

    r2205 r2224  
    125125                float devRelPvsIncrease; 
    126126                int viewcells; 
     127 
     128                float mem; 
    127129        }; 
    128130   

  • GTP/trunk/Lib/Vis/Preprocessing/src/VspTree.h

    r2210 r2224  
    516516                } 
    517517 
    518                 bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet) 
     518                bool Apply(SplitQueue &splitQueue, bool terminationCriteriaMet, SubdivisionCandidateContainer &dirtyList) 
    519519                { 
    520520                        VspNode *n = sVspTree->Subdivide(splitQueue, this, terminationCriteriaMet); 
    521521                         
    522522                        // local or global termination criteria failed 
    523                         return !n->IsLeaf();             
     523                        const bool success = !n->IsLeaf();       
     524 
     525                        if (success) 
     526                                CollectDirtyCandidates(dirtyList, true); 
     527 
     528                        return success; 
    524529                } 
    525530 
    … …  
    556561                float mCorrectedFrontRenderCost; 
    557562                float mCorrectedBackRenderCost; 
    558                 //float mCorrectedFrontVolume; 
    559                 //float mCorrectedBackVolume; 
    560  
     563                 
    561564                float mFrontRenderCost; 
    562565                float mBackRenderCost; 
    … …  
    907910        /** Evaluates contribution of min event to pvs 
    908911        */ 
    909         inline int EvalMinEventContribution( 
    910                 const VssRay &ray, const bool isTermination) const; 
     912        inline int EvalMinEventContribution(const VssRay &ray, const bool isTermination) const; 
    911913 
    912914        /** Evaluates contribution of max event to pvs 
    … …  
    955957                                  RayInfoContainer &backRays) const; 
    956958 
    957         void UpdatePvsEntriesContribution( 
     959        inline void UpdatePvsEntriesContribution( 
    958960                const VssRay &ray, 
    959961                const bool isTermination, 
    … …  
    973975         
    974976        */ 
    975         void UpdateContributionsToPvs( 
     977        inline void UpdateContributionsToPvs( 
    976978                const VssRay &ray, 
    977979                const bool isTermination, 
    … …  
    983985        /** Evaluates the contribution for objects. 
    984986        */ 
    985         void UpdateContributionsToPvs( 
     987        inline void UpdateContributionsToPvs( 
    986988                Intersectable *obj,  
    987989                const int cf,  
    … …  
    992994        /** Evaluates the contribution for bounding volume leaves. 
    993995        */ 
    994         void UpdateContributionsToPvs( 
     996        inline void UpdateContributionsToPvs( 
    995997                BvhLeaf *leaf, 
    996998                const int cf, 
    997999                float &frontPvs, 
    9981000                float &backPvs, 
    999                 float &totalPvsm, 
     1001                float &totalPvs, 
    10001002                const bool countEntries) const; 
    10011003 
    10021004        /** Evaluates the contribution for kd leaves. 
    10031005        */ 
    1004         void UpdateContributionsToPvs( 
     1006        inline void UpdateContributionsToPvs( 
    10051007                KdLeaf *leaf, 
    10061008                const int cf, 
    … …  
    10111013        /** Returns true if tree can be terminated. 
    10121014        */ 
    1013         bool LocalTerminationCriteriaMet(const VspTraversalData &data) const; 
     1015        inline bool LocalTerminationCriteriaMet(const VspTraversalData &data) const; 
    10141016 
    10151017        /** Returns true if global tree can be terminated. 
    10161018        */ 
    1017         bool GlobalTerminationCriteriaMet(const VspTraversalData &data) const; 
     1019        inline bool GlobalTerminationCriteriaMet(const VspTraversalData &data) const; 
    10181020 
    10191021        /** Adds ray sample contributions to the PVS. 
Note: See TracChangeset for help on using the changeset viewer.