Ignore:
Timestamp:
10/26/06 19:35:43 (18 years ago)
Author:
mattausch
Message:

found constant for ratio

Location:
GTP/trunk/Lib/Vis/Preprocessing/src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • GTP/trunk/Lib/Vis/Preprocessing/src/BvHierarchy.cpp

    r1680 r1684  
    338338        //AssociateObjectsWithLeaf(node->GetFront()); 
    339339    
    340         node->mRenderCostDecr += sc.GetRenderCostDecrease(); 
    341         node->mPvsEntriesIncr += sc.GetPvsEntriesIncr(); 
    342  
     340        node->mRenderCostDecr = sc.GetRenderCostDecrease(); 
     341        node->mPvsEntriesIncr = sc.GetPvsEntriesIncr(); 
    343342} 
    344343                                                                         
     
    370369        AxisAlignedBox3 bbox = EvalBoundingBox(sc.mBackObjects, &parentBox); 
    371370 
    372         BvhLeaf *back =  
    373                 new BvhLeaf(bbox, node, (int)sc.mBackObjects.size()); 
    374         BvhLeaf *front =  
    375                 new BvhLeaf(fbox, node, (int)sc.mFrontObjects.size()); 
     371        BvhLeaf *back = new BvhLeaf(bbox, node, (int)sc.mBackObjects.size()); 
     372        BvhLeaf *front = new BvhLeaf(fbox, node, (int)sc.mFrontObjects.size()); 
    376373 
    377374        BvhInterior *parent = leaf->GetParent(); 
     
    428425        backData.mMaxCostMisses = sc.GetMaxCostMisses(); 
    429426         
    430         // set the time stamp so the order of traversal can be reconstructed 
    431         node->mTimeStamp = mHierarchyManager->mTimeStamp ++; 
    432         //cout << "here4 " << node->mTimeStamp << endl; 
    433         node->mRenderCostDecr = sc.GetRenderCostDecrease(); 
    434         node->mPvsEntriesIncr = sc.GetPvsEntriesIncr(); 
     427        //node->mRenderCostDecr = sc.GetRenderCostDecrease(); 
     428        //node->mPvsEntriesIncr = sc.GetPvsEntriesIncr(); 
    435429 
    436430        // assign the objects in sorted order 
     
    465459                currentNode = SubdivideNode(*sc, tFrontData, tBackData); 
    466460         
     461                // set the time stamp so the order of traversal can be reconstructed 
     462                currentNode->mTimeStamp = mHierarchyManager->mTimeStamp ++; 
     463                //currentNode->mRenderCostDecr = sc.GetRenderCostDecrease(); 
     464                //currentNode->mPvsEntriesIncr = sc.GetPvsEntriesIncr(); 
     465 
    467466                // decrease the weighted average cost of the subdivisoin 
    468467                mTotalCost -= sc->GetRenderCostDecrease(); 
     
    12931292                                if (useVisibilityBasedHeuristics) 
    12941293                                { 
    1295                                         cout << "v"; 
     1294                                        //cout << "v rays: " << tData.mNumRays << " " << endl; 
    12961295                                        /////////// 
    12971296                                        //-- heuristics using objects weighted by view cells volume 
     
    13001299                                } 
    13011300                                else 
    1302                                 {       cout << "e"; 
     1301                                {       cout << "e rays: " << tData.mNumRays << " "; 
    13031302                                        ////////////////// 
    13041303                                        //-- view cells not constructed yet     => use surface area heuristic                    
     
    21242123 
    21252124 
    2126 } 
     2125SubdivisionCandidate *BvHierarchy::CreateSubdivisionCandidate(BvhInterior *oldNode) 
     2126{ 
     2127        return new BvhSubdivisionCandidate(BvhTraversalData()); 
     2128} 
     2129 
     2130 
     2131BvhNode *BvHierarchy::SubdivideAndCopy(SplitQueue &tQueue, 
     2132                                                                           SubdivisionCandidate *splitCandidate, 
     2133                                                                           const bool globalCriteriaMet, 
     2134                                                                           BvhNode *originalNode) 
     2135{ 
     2136        BvhSubdivisionCandidate *sc = dynamic_cast<BvhSubdivisionCandidate *>(splitCandidate); 
     2137        BvhTraversalData &tData = sc->mParentData; 
     2138 
     2139        BvhNode *currentNode = tData.mNode; 
     2140        BvhNode *oldNode = (BvhNode *)splitCandidate->mEvaluationHack; 
     2141 
     2142        if (!oldNode->IsLeaf()) 
     2143        {        
     2144                ////////////// 
     2145                //-- continue subdivision 
     2146 
     2147                BvhTraversalData tFrontData; 
     2148                BvhTraversalData tBackData; 
     2149                         
     2150                BvhInterior *oldInterior = dynamic_cast<BvhInterior *>(oldNode); 
     2151                //sc->SetSplitPlane(oldInterior->mSplitPlane); 
     2152 
     2153                oldInterior->GetFront()->CollectObjects(sc->mFrontObjects); 
     2154                oldInterior->GetBack()->CollectObjects(sc->mBackObjects); 
     2155                EvalSubdivisionCandidate(*sc); 
     2156 
     2157                // create new interior node and two leaf node 
     2158                currentNode = SubdivideNode(*sc, tFrontData, tBackData); 
     2159         
     2160                // evaluate the changes in render cost and pvs entries 
     2161                EvalSubdivisionCandidate(*sc, false); 
     2162 
     2163                currentNode->mRenderCostDecr = oldNode->mRenderCostDecr + sc->GetRenderCostDecrease(); 
     2164                currentNode->mPvsEntriesIncr = oldNode->mPvsEntriesIncr + sc->GetPvsEntriesIncr(); 
     2165 
     2166                /////////////////////////// 
     2167                //-- push the new split candidates on the queue 
     2168                 
     2169                BvhSubdivisionCandidate *frontCandidate = new BvhSubdivisionCandidate(tFrontData); 
     2170                BvhSubdivisionCandidate *backCandidate = new BvhSubdivisionCandidate(tBackData); 
     2171 
     2172                frontCandidate->SetPriority((float)-oldInterior->GetFront()->mTimeStamp); 
     2173                backCandidate->SetPriority((float)-oldInterior->GetFront()->mTimeStamp); 
     2174 
     2175                frontCandidate->mEvaluationHack = oldInterior->GetFront(); 
     2176                backCandidate->mEvaluationHack = oldInterior->GetBack(); 
     2177 
     2178                // cross reference 
     2179                tFrontData.mNode->SetSubdivisionCandidate(frontCandidate);  
     2180                tBackData.mNode->SetSubdivisionCandidate(backCandidate); 
     2181 
     2182                //cout << "f: " << frontCandidate->GetPriority() << " b: " << backCandidate->GetPriority() << endl; 
     2183                tQueue.Push(frontCandidate); 
     2184                tQueue.Push(backCandidate); 
     2185        } 
     2186 
     2187        ///////////////////////////////// 
     2188        //-- node is a leaf => terminate traversal 
     2189 
     2190        if (currentNode->IsLeaf()) 
     2191        { 
     2192                // this leaf is no candidate for splitting anymore 
     2193                // => detach subdivision candidate 
     2194                tData.mNode->SetSubdivisionCandidate(NULL);  
     2195                // detach node so we don't delete it with the traversal data 
     2196                tData.mNode = NULL; 
     2197        } 
     2198         
     2199        return currentNode; 
     2200} 
     2201 
     2202 
     2203} 
  • GTP/trunk/Lib/Vis/Preprocessing/src/BvHierarchy.h

    r1680 r1684  
    271271 
    272272        virtual void CollectObjects(ObjectContainer &objects); 
     273 
    273274protected: 
    274275 
     
    306307                mSubdivisionCandidate = candidate;  
    307308        } 
    308 virtual void CollectObjects(ObjectContainer &objects); 
     309         
     310        virtual void CollectObjects(ObjectContainer &objects); 
     311 
    309312public: 
    310313 
     
    597600        float GetMemUsage() const; 
    598601 
    599 void UpdateNode(const BvhSubdivisionCandidate &sc); 
     602 
     603        /////////////////////////// 
     604        // hacks in order to provide interleaved heurisitcs 
     605 
     606        void UpdateNode(const BvhSubdivisionCandidate &sc); 
     607 
     608        SubdivisionCandidate *CreateSubdivisionCandidate(BvhInterior *oldNode); 
     609 
     610        BvhNode *SubdivideAndCopy(SplitQueue &tQueue, 
     611                                                          SubdivisionCandidate *splitCandidate, 
     612                                                          const bool globalCriteriaMet, 
     613                                                          BvhNode *originalNode); 
     614 
     615        ///////////////////////////////// 
    600616 
    601617protected: 
  • GTP/trunk/Lib/Vis/Preprocessing/src/Environment.cpp

    r1676 r1684  
    25662566                                        "200"); 
    25672567 
     2568        RegisterOption("Hierarchy.Construction.maxStepsOfSameType", 
     2569                                        optInt, 
     2570                                        "hierarchy_construction_max_steps_same_type=", 
     2571                                        "700"); 
     2572 
    25682573        RegisterOption("Hierarchy.Construction.recomputeSplitPlaneOnRepair", 
    25692574                                        optBool, 
  • GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.cpp

    r1680 r1684  
    112112                "Hierarchy.Construction.minStepsOfSameType", mMinStepsOfSameType); 
    113113         
     114        Environment::GetSingleton()->GetIntValue( 
     115                "Hierarchy.Construction.maxStepsOfSameType", mMaxStepsOfSameType); 
     116 
    114117        char subdivisionStatsLog[100]; 
    115118        Environment::GetSingleton()->GetStringValue("Hierarchy.subdivisionStats", subdivisionStatsLog); 
     
    128131                "Hierarchy.Termination.maxMemory", mTermMaxMemory); 
    129132 
    130         Environment::GetSingleton()->GetFloatValue( 
    131                 "Hierarchy.Termination.memoryConst", mMemoryConst); 
     133        if (1 && mConsiderMemory2) 
     134        { 
     135                mMemoryConst = (float)(sizeof(VspLeaf *) + sizeof (VspViewCell *)); 
     136        } 
     137        else 
     138        { 
     139                Environment::GetSingleton()->GetFloatValue( 
     140                        "Hierarchy.Termination.memoryConst", mMemoryConst); 
     141        } 
    132142 
    133143        // compare to bytes 
     
    147157        Debug << "consider memory2: " << mConsiderMemory << endl; 
    148158        Debug << "mem const: " << mMemoryConst << endl; 
     159        Debug << "min steps of same kind: " << mMinStepsOfSameType << endl; 
     160        Debug << "max steps of same kind: " << mMaxStepsOfSameType << endl; 
    149161 
    150162        switch (mConstructionType) 
     
    377389        SplitQueue viewSpaceQueue; 
    378390 
     391        int vspSteps, ospSteps; 
     392 
    379393        // use sah for evaluating osp tree construction  
    380394        // in the first iteration of the subdivision 
     
    385399        // number of initial splits 
    386400        const int minSteps = mMinStepsOfSameType; 
    387         const int maxSteps = mMinStepsOfSameType + 500; 
    388         float renderCostDecr = Limits::Infinity; 
     401        const int maxSteps = mMaxStepsOfSameType; 
    389402 
    390403        SubdivisionCandidate *osc = PrepareObjectSpaceSubdivision(sampleRays, objects); 
    391          
    392404        objectSpaceQueue.Push(osc); 
    393405 
     
    396408        // calulcate initial object space splits 
    397409         
    398         SubdivisionCandidateContainer dirtyVspList; 
     410        SubdivisionCandidateContainer dirtyList; 
    399411 
    400412        // subdivide object space first 
    401413        // for first round, use sah splits. Once view space partition 
    402414        // has started, use render cost heuristics instead 
    403         const int ospSteps =  
    404                 RunConstruction(objectSpaceQueue, dirtyVspList, NULL, minSteps, maxSteps); 
    405  
     415        ospSteps = RunConstruction(objectSpaceQueue, dirtyList, NULL, minSteps, maxSteps); 
    406416        cout << "\n" << ospSteps << " object space partition steps taken" << endl; 
    407417 
    408418        // create view space 
    409419        SubdivisionCandidate *vsc = PrepareViewSpaceSubdivision(sampleRays, objects); 
    410  
    411420        viewSpaceQueue.Push(vsc); 
    412          
     421 
     422        dirtyList.clear(); 
     423 
    413424        // view space subdivision started 
    414425        mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType; 
    415426 
    416         // the priorities were calculated for driving sha. 
    417         // => recalculate "real" priorities taking visibility into 
    418         // account so we can compare to view space splits 
    419         ResetQueue(objectSpaceQueue, false); 
     427        if (1) 
     428        { 
     429                // rather also start with 100 view space splits to avoid initial bias. 
     430                vspSteps = RunConstruction(viewSpaceQueue, dirtyList, NULL, minSteps, maxSteps); 
     431                cout << "\n" << vspSteps << " view space partition steps taken" << endl; 
     432                 
     433                /// Repair split queue 
     434                cout << "repairing queue ... " << endl; 
     435                RepairQueue(dirtyList, objectSpaceQueue, true); 
     436                cout << "repaired " << (int)dirtyList.size() << " candidates" << endl; 
     437 
     438                dirtyList.clear(); 
     439        } 
     440        else 
     441        { 
     442                // the priorities were calculated for driving sah. 
     443                // => recalculate "real" priorities taking visibility into 
     444                // account so we can compare to view space splits 
     445                ResetQueue(objectSpaceQueue, false); 
     446        } 
    420447 
    421448        // This method subdivides view space / object space  
     
    424451        // then optimizate view space partition for the current osp 
    425452        // and vice versa until iteration depth is reached. 
    426 bool lastSplitWasOsp = true; 
     453        bool lastSplitWasOsp = true; 
     454 
    427455        while (!(viewSpaceQueue.Empty() && objectSpaceQueue.Empty())) 
    428456        { 
     
    434462 
    435463                // should view or object space be subdivided further? 
    436                 //if (ospPriority >= vspPriority) 
    437                 if (!lastSplitWasOsp) 
     464                if (ospPriority >= vspPriority) 
     465                //if (!lastSplitWasOsp) 
    438466                { 
    439467                        lastSplitWasOsp = true; 
    440468                        cout << "osp" << endl; 
     469                         
    441470                        // dirtied view space candidates 
    442471                        SubdivisionCandidateContainer dirtyVspList; 
     
    445474                        // for first round, use sah splits. Once view space partition 
    446475                        // has started, use render cost heuristics instead 
    447                         const int ospSteps = RunConstruction(objectSpaceQueue,  
    448                                                                                                  dirtyVspList,  
    449                                                                                                  viewSpaceQueue.Top(),  
    450                                                                                                  minSteps,  
    451                                                                                                  maxSteps); 
     476                        const int ospSteps =  
     477                                RunConstruction(objectSpaceQueue, dirtyVspList, viewSpaceQueue.Top(), minSteps, maxSteps); 
    452478 
    453479                        cout << "\n" << ospSteps << " object space partition steps taken" << endl; 
    454                  
     480                        Debug << "\n" << ospSteps << " object space partition steps taken" << endl; 
     481 
    455482                        /// Repair split queue, i.e., affected view space candidates 
    456483                        cout << "repairing queue ... " << endl; 
     
    466493                        // subdivide view space with respect to the objects 
    467494 
     495                        // dirtied object space candidates 
    468496                        SubdivisionCandidateContainer dirtyOspList; 
    469497 
     
    473501 
    474502                        cout << "\n" << vspSteps << " view space partition steps taken" << endl; 
     503                        Debug << "\n" << vspSteps << " view space partition steps taken" << endl; 
    475504 
    476505                        // view space subdivision constructed 
     
    717746        { 
    718747                memoryCount += 100000; 
    719                 cout << "\nstorage cost: " << mHierarchyStats.mMemory / float(1024 * 1024) << " MB, steps: " << mHierarchyStats.Leaves() << endl; 
     748                cout << "\nstorage cost: " << mHierarchyStats.mMemory / float(1024 * 1024)  
     749                         << " MB, steps: " << mHierarchyStats.Leaves() << endl; 
    720750        } 
    721751 
     
    917947                const float threshold = oldCandidate ? oldCandidate->GetPriority() : 1e20; 
    918948                SubdivisionCandidate *sc = NextSubdivisionCandidate(splitQueue);  
    919                 //cout << "here2 " << sc->GetRenderCostDecrease() << " " << threshold << endl; 
     949                 
    920950                float rc = (float)sc->GetRenderCostDecrease() / (mInitialRenderCost - mHierarchyStats.mTotalCost + 1.0f); 
    921951                float mc = (float)sc->GetPvsEntriesIncr() / (float)mHierarchyStats.mPvsEntries;  
     
    940970                { 
    941971                        sc->CollectDirtyCandidates(dirtyCandidates, true); 
    942                         //cout << "collected " << dirtyCandidates.size() << "dirty candidates" << endl; 
    943972                        ++ steps; 
    944973                } 
     
    12811310         
    12821311 
    1283         ///////////////////////////////// 
     1312        /////////////////////////// 
    12841313        //-- reevaluate the dirty list 
    12851314 
     
    16111640 
    16121641        VspTree *oldVspTree = mVspTree; 
    1613         //BvHierarchy *oldHierarchy = mBvHierarchy; 
    1614  
    1615         //mBvHierarchy = new BvHierarchy(); 
    1616         //mBvHierarchy->mHierarchyManager = this; 
     1642        BvHierarchy *oldHierarchy = mBvHierarchy; 
     1643 
     1644        mBvHierarchy = new BvHierarchy(); 
     1645        mBvHierarchy->mHierarchyManager = this; 
    16171646         
    16181647        mVspTree = new VspTree(); 
     
    16361665        cout << "Constructing view space / object space tree ... \n"; 
    16371666         
    1638         ExportStats(filename, objects, oldVspTree); 
     1667        ExportStats(filename, objects, oldVspTree, oldHierarchy); 
    16391668 
    16401669        cout << "\nfinished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl; 
     
    16491678void HierarchyManager::ExportStats(const string &mergeStats, 
    16501679                                                                   const ObjectContainer &objects, 
    1651                                                                    VspTree *oldVspTree) 
     1680                                                                   VspTree *oldVspTree, 
     1681                                                                   BvHierarchy *oldHierarchy) 
    16521682{ 
    16531683        ofstream stats; 
    16541684        stats.open(mergeStats.c_str()); 
     1685        SplitQueue tQueue; 
     1686 
     1687        BvhNode *oldBvhRoot = oldHierarchy->GetRoot(); 
     1688        VspNode *oldVspRoot = oldVspTree->GetRoot(); 
     1689 
     1690        SubdivisionCandidate *firstVsp = mVspTree->CreateSubdivisionCandidate(dynamic_cast<VspInterior *>(oldVspRoot)); 
     1691        SubdivisionCandidate *firstBvh = mBvHierarchy->CreateSubdivisionCandidate(dynamic_cast<BvhInterior *>(oldBvhRoot)); 
     1692 
    16551693/* 
    16561694        BvhQueue bvhQueue; 
     
    16741712        ///////////// 
    16751713        //-- first view cell 
    1676 //      UpdateStats(stats, 2, totalRenderCost, entriesInPvs, memoryCost, true); 
    1677  
    1678  
    1679 /* 
    1680  
     1714        UpdateStats(stats, 2, totalRenderCost, entriesInPvs, memoryCost, true); 
    16811715 
    16821716        //-- go through tree in the order of render cost decrease 
     
    16841718        //-- or the reverse order of subdivision for subdivision-only  
    16851719        //-- view cell hierarchies. 
    1686         int i = 0; 
     1720        int steps = 0; 
     1721        while (!tQueue.Empty()) 
     1722        { 
     1723                SubdivisionCandidate *nextCandidate = NextSubdivisionCandidate(tQueue); 
     1724                 
     1725                cout << "next candidate: " << nextCandidate->GetPriority() << endl; 
     1726                nextCandidate->Apply(tQueue, false); 
     1727 
     1728                totalRenderCost -= nextCandidate->GetRenderCostDecrease(); 
     1729                entriesInPvs += nextCandidate->GetPvsEntriesIncr(); 
     1730 
     1731                ++ steps; 
     1732                 
     1733                const float memoryCost = (float)entriesInPvs * (float)ObjectPvs::GetEntrySize(); 
     1734                UpdateStats(stats, steps, totalRenderCost, entriesInPvs, memoryCost, false); 
     1735 
     1736                /*if (nextCandidate->Type() == SubdivisionCandidate::VIEW_SPACE) 
     1737                { 
     1738                        cout << "v"; 
     1739                        VspNode *vspNode = NULL; 
     1740 
     1741                        //vspNode->mParent->SetupChildLink(); 
     1742                        if (!vspNode->IsLeaf())  
     1743                        {        
     1744                                SubdivisionCandidate sc = new VspSubdivisionCandidate(); 
     1745 
     1746                                mVspTree->EvalPriority(sc, false); 
     1747 
     1748                                UpdateStats(stats, splits 
     1749                                totalRenderCost -= vspNode->mRenderCostDecr; 
     1750                                entriesInPvs += vspNode->mPvsEntriesIncr;                
     1751 
     1752                                steps ++; 
     1753 
     1754                                const float memoryCost = (float)entriesInPvs * (float)ObjectPvs::GetEntrySize();         
     1755                                UpdateStats(stats, steps, totalRenderCost, entriesInPvs, memoryCost, true); 
     1756 
     1757                                VspNode *front = dynamic_cast<VspInterior *>(vspNode)->GetFront(); 
     1758                                VspNode *back= dynamic_cast<VspInterior *>(vspNode)->GetBack(); 
     1759 
     1760                                RecreateLeaves(); 
     1761                                if (!front->IsLeaf()) 
     1762                                { 
     1763                                SuddivisionCandidate *candidate = new SubdivisionCandidate; 
     1764                                candidate->mParentData.mNode ? front; 
     1765                                candidate->mParentData.mrays = 0; 
     1766                         
     1767                                SuddivisionCandidate *candidate2 = new SubdivisionCandidate; 
     1768                                candidate->mParentData.mNode = back; 
     1769                                candidate->mParentData.mrays = 0; 
     1770 
     1771 
     1772                                        vspQueue.push(front); 
     1773                                if (!back->IsLeaf()) 
     1774                                        vspQueue.push(back); 
     1775                                 
     1776                        } 
     1777                } 
     1778                else // object space split 
     1779                { 
     1780                        cout << "o"; 
     1781                         
     1782                        BvhNode *bvhNode = NULL; 
     1783                 
     1784                        if (!bvhNode->IsLeaf())  
     1785                        {        
     1786                                totalRenderCost -= bvhNode->mRenderCostDecr; 
     1787                                entriesInPvs += bvhNode->mPvsEntriesIncr;                
     1788 
     1789                                steps ++; 
     1790                                const float memoryCost = (float)entriesInPvs * (float)ObjectPvs::GetEntrySize();         
     1791                                UpdateStats(stats, steps, totalRenderCost, entriesInPvs, memoryCost, false); 
     1792                                 
     1793                        //      BvhNode *front = dynamic_cast<BvhInterior *>(bvhNode)->GetFront(); 
     1794                        //      BvhNode *back= dynamic_cast<BvhInterior *>(bvhNode)->GetBack(); 
     1795 
     1796                        //      if (!front->IsLeaf()) 
     1797                        //              bvhQueue.push(front); 
     1798                        //      if (!back->IsLeaf()) 
     1799                        //              bvhQueue.push(back); 
     1800                        } 
     1801                }*/ 
     1802        } 
     1803        stats.close(); 
     1804} 
     1805 
     1806        /* 
    16871807        while (!(bvhQueue.empty() && vspQueue.empty())) 
    16881808        { 
     
    17751895        } 
    17761896*/ 
    1777         stats.close(); 
    1778 } 
    1779  
    1780  
    1781 } 
     1897 
     1898 
     1899} 
  • GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.h

    r1680 r1684  
    444444                                                const string &filename); 
    445445 
    446 void ExportStats(const string &mergeStats, const ObjectContainer &objects, VspTree *oldVspTree); 
     446void ExportStats(const string &mergeStats, const ObjectContainer &objects, VspTree *oldVspTree, BvHierarchy *oldBvHierarchy); 
    447447protected: 
    448448 
     
    509509        /// number of minimal steps of the same type 
    510510        int mMinStepsOfSameType; 
     511        int mMaxStepsOfSameType; 
    511512 
    512513        /// statistics about the hierarchy 
  • GTP/trunk/Lib/Vis/Preprocessing/src/SubdivisionCandidate.h

    r1667 r1684  
    3838        */ 
    3939        virtual bool GlobalTerminationCriteriaMet() const = 0; 
    40         /** Collects #of subdivision candidates that were affected by the 
     40        /** Collects subdivision candidates that were affected by the 
    4141                application of this one. 
    4242        */ 
     
    117117        static int sReservedMailboxes; 
    118118 
     119        void *mEvaluationHack; 
    119120protected: 
    120121 
  • GTP/trunk/Lib/Vis/Preprocessing/src/VspTree.cpp

    r1680 r1684  
    33213321 
    33223322 
    3323 } 
     3323SubdivisionCandidate *VspTree::CreateSubdivisionCandidate(VspInterior *oldNode) 
     3324{ 
     3325        return new VspSubdivisionCandidate(oldNode->GetPlane(), VspTraversalData()); 
     3326} 
     3327 
     3328} 
  • GTP/trunk/Lib/Vis/Preprocessing/src/VspTree.h

    r1680 r1684  
    694694 
    695695        void UpdateNode(const AxisAlignedPlane &splitPlane, 
    696                                                          VspTraversalData &tData, 
    697                                                         VspTraversalData &frontData, 
    698                                                          VspTraversalData &backData); 
     696                                    VspTraversalData &tData, 
     697                                        VspTraversalData &frontData, 
     698                                        VspTraversalData &backData); 
     699 
     700        SubdivisionCandidate *CreateSubdivisionCandidate(VspInterior *oldNode); 
     701 
    699702protected: 
    700703 
Note: See TracChangeset for help on using the changeset viewer.