Ignore:
Timestamp:
07/10/06 15:57:11 (18 years ago)
Author:
mattausch
Message:

working on vsp osp (should I create view cells in each step?)

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

Legend:

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

    r1089 r1108  
    163163  //  cerr<<"\n OBJECTS="<<leaf->mObjects.size()<<endl; 
    164164  return 
    165     (leaf->mObjects.size() <= mTermMinCost) || 
     165    ((int)leaf->mObjects.size() <= mTermMinCost) || 
    166166    (leaf->mDepth >= mTermMaxDepth); 
    167167   
  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

    r1107 r1108  
    50395039        } 
    50405040         
    5041          
    50425041        VspInterior *interior = dynamic_cast<VspInterior *>(root); 
    50435042        ViewCellInterior *viewCellInterior = new ViewCellInterior(); 
     
    54455444                if (1) 
    54465445                {       //-- export pvs 
     5446 
    54475447                        ObjectPvsMap::const_iterator oit, 
    54485448                                oit_end = pvs.mEntries.end(); 
     
    54605460                        for (oit = pvs.mEntries.begin(); oit != oit_end; ++ oit) 
    54615461                        {        
    5462                                 // "original" pvs 
     5462                                // exportŽ"original" pvs 
    54635463                                Intersectable *obj = (*oit).first; 
    54645464 
     
    54875487                        exporter->SetForcedMaterial(m); 
    54885488 
    5489                         // export kd node pvs 
     5489                        //-- export kd node pvs 
    54905490                        Intersectable::NewMail(); 
    54915491 
  • GTP/trunk/Lib/Vis/Preprocessing/src/VrmlExporter.cpp

    r1107 r1108  
    659659        vector<KdLeaf *>::const_iterator it, it_end = leaves.end(); 
    660660 
     661        Material white;  
     662        white.mDiffuseColor.r = 1; 
     663        white.mDiffuseColor.g = 1; 
     664        white.mDiffuseColor.b = 1; 
     665 
    661666        for (it = leaves.begin(); it != it_end; ++ it) 
    662667        { 
    663668                SetWireframe(); 
     669                SetForcedMaterial(white); 
    664670                ExportBox(ospTree.GetBBox(*it)); 
    665671 
     672                SetFilled(); 
    666673                SetForcedMaterial(RandomMaterial()); 
    667  
    668674                ExportGeometry((*it)->mObjects);         
    669675        } 
  • GTP/trunk/Lib/Vis/Preprocessing/src/VspOspTree.cpp

    r1106 r1108  
    467467                        mBoundingBox.Include(ray->GetOrigin()); 
    468468                } 
    469  
    470                 mTermMinProbability *= mBoundingBox.GetVolume(); 
    471                 mGlobalCostMisses = 0; 
    472         } 
     469        } 
     470 
     471        mTermMinProbability *= mBoundingBox.GetVolume(); 
     472        mGlobalCostMisses = 0; 
    473473} 
    474474 
     
    517517bool VspTree::GlobalTerminationCriteriaMet(const VspTraversalData &data) const 
    518518{ 
     519        Debug << "cost misses " << mGlobalCostMisses << " " << mTermGlobalCostMissTolerance << endl; 
     520        Debug << "leaves " << mVspStats.Leaves() << " " <<  mMaxViewCells << endl; 
     521 
    519522        return ( 
    520523//              mOutOfMemory ||  
     
    525528 
    526529 
     530void VspTree::CreateViewCell(VspTraversalData &tData) 
     531{ 
     532        //-- create new view cell 
     533        VspLeaf *leaf = dynamic_cast<VspLeaf *>(tData.mNode); 
     534         
     535        VspViewCell *viewCell = new VspViewCell(); 
     536    leaf->SetViewCell(viewCell); 
     537                 
     538        //-- update pvs 
     539        int conSamp = 0; 
     540        float sampCon = 0.0f; 
     541        AddToPvs(leaf, *tData.mRays, sampCon, conSamp); 
     542 
     543        // update scalar pvs size value 
     544        mViewCellsManager->SetScalarPvsSize(viewCell, viewCell->GetPvs().GetSize()); 
     545 
     546        mVspStats.contributingSamples += conSamp; 
     547        mVspStats.sampleContributions +=(int) sampCon; 
     548 
     549        //-- store additional info 
     550        if (mStoreRays) 
     551        { 
     552                RayInfoContainer::const_iterator it, it_end = tData.mRays->end(); 
     553                for (it = tData.mRays->begin(); it != it_end; ++ it) 
     554                { 
     555                        (*it).mRay->Ref();                       
     556                        leaf->mVssRays.push_back((*it).mRay); 
     557                } 
     558        } 
     559                 
     560        viewCell->mLeaf = leaf; 
     561 
     562        viewCell->SetVolume(tData.mProbability); 
     563    leaf->mProbability = tData.mProbability; 
     564 
     565        mVspStats.contributingSamples += conSamp; 
     566        mVspStats.sampleContributions +=(int) sampCon; 
     567 
     568        // finally evaluate statistics for this leaf 
     569        EvaluateLeafStats(tData); 
     570} 
     571 
     572 
    527573VspNode *VspTree::Subdivide(SplitQueue &tQueue, 
    528574                                                        VspSplitCandidate &splitCandidate, 
     
    551597                tBackData.mMaxCostMisses = maxCostMisses; 
    552598                         
    553                 //-- statistics 
     599                 
    554600                if (1) 
    555601                { 
     602                        //-- subdivision statistics 
     603 
    556604                        const float cFront = (float)tFrontData.mPvs * tFrontData.mProbability; 
    557605                        const float cBack = (float)tBackData.mPvs * tBackData.mProbability; 
     
    572620 
    573621         
    574                 //-- push the new split candidates on the queue 
     622                //-- evaluate new split candidates for global greedy cost heuristics 
    575623                VspSplitCandidate *frontCandidate = new VspSplitCandidate(tFrontData); 
    576624                VspSplitCandidate *backCandidate = new VspSplitCandidate(tBackData); 
     
    586634        } 
    587635 
    588  
    589         //-- terminate traversal and create new view cell 
     636        // subdivision terminated 
    590637        if (newNode->IsLeaf()) 
    591638        { 
    592                 VspLeaf *leaf = dynamic_cast<VspLeaf *>(newNode); 
    593          
    594                 VspViewCell *viewCell = new VspViewCell(); 
    595         leaf->SetViewCell(viewCell); 
    596                  
    597                 //-- update pvs 
    598                 int conSamp = 0; 
    599                 float sampCon = 0.0f; 
    600                 AddToPvs(leaf, *tData.mRays, sampCon, conSamp); 
    601  
    602                 // update scalar pvs size value 
    603                 mViewCellsManager->SetScalarPvsSize(viewCell, viewCell->GetPvs().GetSize()); 
    604  
    605                 mVspStats.contributingSamples += conSamp; 
    606                 mVspStats.sampleContributions +=(int) sampCon; 
    607  
     639                //-- create new view cell 
     640                CreateViewCell(tData); 
     641         
    608642                //-- store additional info 
    609643                if (mStoreRays) 
     
    613647                        { 
    614648                                (*it).mRay->Ref();                       
    615                                 leaf->mVssRays.push_back((*it).mRay); 
    616                         } 
    617                 } 
    618                  
    619                 viewCell->mLeaf = leaf; 
    620  
    621                 viewCell->SetVolume(tData.mProbability); 
    622         leaf->mProbability = tData.mProbability; 
    623  
    624                 // finally evaluate stats until this leaf 
     649                                dynamic_cast<VspLeaf *>(newNode)->mVssRays.push_back((*it).mRay); 
     650                        } 
     651                } 
     652 
     653                // finally evaluate statistics for this leaf 
    625654                EvaluateLeafStats(tData); 
    626655        } 
     
    661690         
    662691        //-- the front and back traversal data is filled with the new values 
     692 
    663693        frontData.mDepth = tData.mDepth + 1; 
    664694        frontData.mRays = new RayInfoContainer(); 
     
    672702                          *frontData.mRays, 
    673703                          *backData.mRays); 
     704 
     705        // TODO:  
     706        // create front and back view cell 
     707        // remove "parent" view cell from pvs of all objects (traverse trough rays) 
     708        // add front and back view cell to "Potentially Visbilie View Cells"  
     709        // of the objects in front and back pvs 
    674710 
    675711        //Debug << "f: " << frontData.mRays->size() << " b: " << backData.mRays->size() << "d: " << tData.mRays->size() << endl; 
     
    10121048 
    10131049 
    1014 int VspTree::GetPvsIncr(Intersectable *object, const KdPvsMap &activeNodes) 
    1015 { 
    1016         // TODO: 
    1017         // use kd info table to apply set theory in order to 
    1018         // sort out dublicate pvs entries due to objects which 
    1019         // belong to more than one kd leaves. 
    1020 #if TODO 
    1021         KdPvsMap::const_iterator kit, kit_end = obj->mKdPvs.mEntries.end(); 
    1022  
    1023         // Search kd leaves this object is attached to 
    1024         for (kit = obj->mKdPvs.mEntries.begin(); kit != kit_end; ++ kit) 
    1025         { 
    1026                 KdNode *l = (*kit).first; 
    1027  
    1028                 // new object found during sweep  
    1029                 // => increase pvs contribution of this kd node 
    1030                 if (!l->Mailed()) 
    1031                 { 
    1032                         l->Mail(); 
    1033                         ++ pvsContr; 
    1034                 } 
    1035         } 
    1036 #endif 
    1037         return 0; 
    1038 } 
    1039  
    1040  
    10411050void VspTree::RemoveContriFromPvs(KdLeaf *leaf, int &pvs) const 
    10421051{ 
     
    12001209        pvsSize = PrepareHeuristics(rays); 
    12011210 
    1202         Debug << "here45 pvs: " << pvsSize << endl; 
    1203  
    12041211        // go through the lists, count the number of objects left and right 
    12051212        // and evaluate the following cost funcion: 
     
    12291236        vector<SortableEntry>::const_iterator ci, ci_end = mSplitCandidates->end(); 
    12301237 
    1231 Debug << "****************" << endl; 
    12321238        //-- traverse through visibility events 
    12331239 
     
    13381344                        { 
    13391345                                //-- split plane position is spatial median 
    1340  
    13411346                                nPosition[axis] = (box.Min()[axis] + box.Max()[axis]) * 0.5f; 
    1342  
    13431347                                nCostRatio[axis] = EvalLocalSplitCost(tData, 
    13441348                                                                                                          box, 
     
    13611365 
    13621366 
    1363         //-- assign values 
     1367        //-- assign values of best split 
    13641368         
    13651369        plane.mAxis = bestAxis; 
    1366         // split plane position 
    1367     plane.mPosition = nPosition[bestAxis]; 
     1370        plane.mPosition = nPosition[bestAxis]; // split plane position 
    13681371 
    13691372        pFront = nProbFront[bestAxis]; 
     
    14751478        } 
    14761479 
    1477         //-- pvs heuristics 
     1480        //-- cost heuristics 
    14781481        float pOverall; 
    1479  
    1480         //-- compute heurstics 
    14811482         
    14821483        pOverall = data.mProbability; 
    1483         // we take simplified computation for mid split 
     1484 
     1485        // we take simplified computation for spatial mid split 
    14841486        pBack = pFront = pOverall * 0.5f; 
    14851487         
     1488        const float newCost = pvsBack * pBack + pvsFront * pFront; 
     1489        const float oldCost = (float)pvsSize * pOverall + Limits::Small; 
    14861490         
    14871491#ifdef _DEBUG 
     
    14891493        Debug << pFront << " " << pBack << " " << pOverall << endl; 
    14901494#endif 
    1491  
    1492          
    1493         const float newCost = pvsBack * pBack + pvsFront * pFront; 
    1494         const float oldCost = (float)pvsSize * pOverall + Limits::Small; 
    14951495 
    14961496        return  (mCtDivCi + newCost) / oldCost; 
     
    26422642 
    26432643KdInterior *OspTree::SubdivideNode( 
    2644                                                                    KdLeaf *leaf, 
    26452644                                                                   const AxisAlignedPlane &splitPlane, 
    2646                                                                    const AxisAlignedBox3 &box, 
     2645                                                                   const OspTraversalData &tData, 
    26472646                                                                   OspTraversalData &frontData, 
    26482647                                                                   OspTraversalData &backData 
    26492648                                                                   ) 
    26502649{ 
     2650        KdLeaf *leaf = tData.mNode; 
     2651         
     2652        // two new leaves 
    26512653    mOspStats.nodes += 2; 
    26522654 
     
    26592661        node->mAxis = axis; 
    26602662        node->mPosition = position; 
    2661         node->mBox = box; 
    2662  
    2663         backData.mBoundingBox = box; 
    2664         frontData.mBoundingBox = box; 
    2665    
    2666         // first count ray sides 
     2663        node->mBox = tData.mBoundingBox; 
     2664 
     2665 
     2666        //-- the front and back traversal data is filled with the new values 
     2667 
     2668        // bounding boxes: split front and back node geometry 
     2669        tData.mBoundingBox.Split(splitPlane.mAxis, splitPlane.mPosition,  
     2670                frontData.mBoundingBox, backData.mBoundingBox); 
     2671 
     2672        frontData.mDepth = backData.mDepth = tData.mDepth + 1; 
     2673                 
     2674        // TODO matt: compute pvs 
     2675        frontData.mPvs = 999; // ComputePvsSize(*frontData.mRays); 
     2676        backData.mPvs = -999; //ComputePvsSize(*backData.mRays); 
     2677 
     2678        frontData.mProbability = frontData.mBoundingBox.GetVolume(); 
     2679 
     2680 
     2681        // classify objects 
    26672682        int objectsBack = 0; 
    26682683        int objectsFront = 0; 
    2669    
    2670         backData.mBoundingBox.SetMax(axis, position); 
    2671         frontData.mBoundingBox.SetMin(axis, position); 
    26722684 
    26732685        ObjectContainer::const_iterator mi, mi_end = leaf->mObjects.end(); 
     
    27232735                                                   OspSplitCandidate &splitCandidate, 
    27242736                                                   const bool globalCriteriaMet) 
    2725 {Debug << "here11" << endl; 
     2737{ 
    27262738        OspTraversalData &tData = splitCandidate.mParentData; 
    2727 Debug << "here993" << endl; 
    27282739        KdNode *newNode = tData.mNode; 
    27292740 
    2730 Debug << "here996" << endl; 
    27312741        if (!LocalTerminationCriteriaMet(tData) && !globalCriteriaMet) 
    27322742        {        
    27332743                OspTraversalData tFrontData; 
    27342744                OspTraversalData tBackData; 
    2735 Debug << "here3" << endl; 
     2745 
    27362746                //-- continue subdivision 
    27372747                 
     
    27392749                const AxisAlignedPlane splitPlane = splitCandidate.mSplitPlane; 
    27402750                 
    2741                 newNode = SubdivideNode(dynamic_cast<KdLeaf *>(newNode),  
    2742                                                                 splitPlane,  
    2743                                                                 tData.mBoundingBox,  
     2751                newNode = SubdivideNode(splitPlane,  
     2752                                                                tData,  
    27442753                                                                tFrontData,  
    27452754                                                                tBackData); 
     
    27552764                OspSplitCandidate *backCandidate = new OspSplitCandidate(tBackData); 
    27562765 
    2757                 Debug << "here 54 " << tFrontData.mNode << " " <<  tBackData.mNode << endl; 
    2758  
    27592766                EvalSplitCandidate(*frontCandidate); 
    27602767                EvalSplitCandidate(*backCandidate); 
     
    27732780                EvaluateLeafStats(tData);                
    27742781        } 
    2775         Debug << "here888 "<< endl; 
     2782         
    27762783        //-- cleanup 
    27772784        tData.Clear(); 
    2778         Debug << "here876"<< endl; 
     2785         
    27792786        return newNode; 
    27802787} 
     
    30033010        return 1; 
    30043011#else 
    3005         ViewCellPvsMap::const_iterator vit, vit_end = object->mViewCellPvs.mEntries.end(); 
    3006          
    3007         int pvsSize = 0; 
    3008  
    3009         for (vit = object->mViewCellPvs.mEntries.begin(); vit != vit_end; ++ vit) 
    3010         { 
    3011         ViewCell *vc = (*vit).first; 
    3012  
    3013                 if (!vc->Mailed()) 
    3014                 { 
    3015                         vc->Mail(); 
    3016                         vc->mCounter = 1; 
    3017                         ++ pvsSize; 
    3018                 } 
    3019                 else 
    3020                 { 
    3021                         ++ vc->mCounter; 
    3022                 } 
    3023         } 
    3024  
    3025         return pvsSize; 
     3012        // the priotity of the object is the number of view cell pvs entries of the object 
     3013        return object->mViewCellPvs.GetSize(); 
    30263014#endif 
    30273015} 
     
    30413029        { 
    30423030                Intersectable *obj = *oit; 
    3043  
    30443031                pvsSize += PrepareHeuristics(obj);               
    30453032        } 
     
    30853072        -- pvs; 
    30863073#else 
    3087         ViewCellPvsMap::const_iterator vit, vit_end = object->mViewCellPvs.mEntries.end(); 
    3088          
    3089         for (vit = object->mViewCellPvs.mEntries.begin(); vit != vit_end; ++ vit) 
    3090         { 
    3091         ViewCell *vc = (*vit).first; 
    3092  
    3093                 if (-- vc->mCounter == 0) 
    3094                 { 
    3095                         -- pvs; 
    3096                 } 
    3097         } 
     3074        // the cost of an object is the number of view cells it is part of 
     3075        pvs -= object->mViewCellPvs.GetSize(); 
    30983076#endif 
    30993077} 
     
    31023080void OspTree::AddContriToPvs(Intersectable *object, int &pvs) const 
    31033081{ 
    3104         ViewCellPvsMap::const_iterator vit, vit_end = object->mViewCellPvs.mEntries.end(); 
    3105  
    31063082#if COUNT_OBJECTS 
    31073083        ++ pvs; 
    31083084#else 
    3109         for (vit = object->mViewCellPvs.mEntries.begin(); vit != vit_end; ++ vit) 
    3110         { 
    3111         ViewCell *vc = (*vit).first; 
    3112  
    3113                 if (!vc->Mailed()) 
    3114                 { 
    3115                         vc->Mail();              
    3116                         ++ pvs; 
    3117                 } 
    3118         } 
     3085        // the cost of an object is the number of view cells it is part of 
     3086        pvs += object->mViewCellPvs.GetSize(); 
    31193087#endif 
    31203088} 
     
    32183186 
    32193187        // probability that view point lies in back / front node 
    3220         float pOverall = data.mProbability; 
     3188        float pOverall = data.mBoundingBox.GetVolume();//data.mProbability; 
    32213189        float pFront = 0; 
    32223190        float pBack = 0; 
    3223  
    32243191 
    32253192        Intersectable::NewMail(); 
     
    32343201                Intersectable *obj = *oit; 
    32353202                const AxisAlignedBox3 box = obj->GetBox(); 
     3203                 
     3204                const float pvsIncr = EvalViewCellPvsIncr(obj); 
     3205                totalPvs += pvsIncr; 
    32363206 
    32373207                if (box.Max(candidatePlane.mAxis) > candidatePlane.mPosition) 
    3238                         pvsFront += EvalViewCellPvsIncr(obj); 
     3208                { 
     3209                        pvsFront += pvsIncr; 
     3210                } 
    32393211                if (box.Min(candidatePlane.mAxis) > candidatePlane.mPosition) 
    3240                         pvsBack += EvalViewCellPvsIncr(obj); 
     3212                { 
     3213                        pvsBack += pvsIncr; 
     3214                } 
    32413215        } 
    32423216 
     
    32563230 
    32573231        //-- only render cost heuristics or combined with standard deviation 
    3258         const float penaltyOld = EvalPvsPenalty((int)totalPvs, lowerPvsLimit, upperPvsLimit); 
    3259     const float penaltyFront = EvalPvsPenalty((int)pvsFront, lowerPvsLimit, upperPvsLimit); 
    3260         const float penaltyBack = EvalPvsPenalty((int)pvsBack, lowerPvsLimit, upperPvsLimit); 
     3232        const float penaltyOld = totalPvs;//EvalPvsPenalty((int)totalPvs, lowerPvsLimit, upperPvsLimit); 
     3233    const float penaltyFront = pvsFront;//EvalPvsPenalty((int)pvsFront, lowerPvsLimit, upperPvsLimit); 
     3234        const float penaltyBack = pvsBack;//EvalPvsPenalty((int)pvsBack, lowerPvsLimit, upperPvsLimit); 
    32613235                         
     3236        Debug << "total pvs: " << totalPvs << " p " << pOverall << endl; 
    32623237        const float oldRenderCost = pOverall * penaltyOld; 
    32633238        const float newRenderCost = penaltyFront * pFront + penaltyBack * pBack; 
    32643239 
    3265         //Debug << "decrease: " << oldRenderCost - newRenderCost << endl; 
     3240        Debug << "old: " << oldRenderCost << " new: " << newRenderCost << " decrease: " << oldRenderCost - newRenderCost << endl; 
    32663241        const float renderCostDecrease = (oldRenderCost - newRenderCost) / mBoundingBox.GetVolume(); 
    32673242         
     
    33033278                        mBoundingBox.Include(obj->GetBox()); 
    33043279                } 
    3305  
    3306                 mTermMinProbability *= mBoundingBox.GetVolume(); 
    3307                 mGlobalCostMisses = 0; 
    3308         } 
     3280        } 
     3281 
     3282        mTermMinProbability *= mBoundingBox.GetVolume(); 
     3283        mGlobalCostMisses = 0; 
    33093284} 
    33103285 
     
    35033478bool HierarchyManager::GlobalTerminationCriteriaMet(SplitCandidate *candidate) const 
    35043479{ 
    3505         if (candidate->Type() == SplitCandidate::VIEW_SPACE) 
    3506         { 
    3507                 VspTree::VspSplitCandidate *sc =  
    3508                         dynamic_cast<VspTree::VspSplitCandidate *>(candidate); 
    3509                  
    3510                 return mVspTree.GlobalTerminationCriteriaMet(sc->mParentData); 
    3511         } 
    3512         else 
    3513         { 
    3514                 OspTree::OspSplitCandidate *sc =  
    3515                         dynamic_cast<OspTree::OspSplitCandidate *>(candidate); 
    3516                  
    3517                 return mOspTree.GlobalTerminationCriteriaMet(sc->mParentData); 
    3518         } 
    3519  
    3520         return true; 
     3480        // TODO matt: make virtual by creating superclasss for traveral data 
     3481        return candidate->GlobalTerminationCriteriaMet(); 
    35213482} 
    35223483 
     
    35953556                        GlobalTerminationCriteriaMet(splitCandidate); 
    35963557 
    3597                 cout << "view cells: " << i ++ << endl; 
     3558                //cout << "vsp nodes: " << i ++ << endl; 
    35983559 
    35993560                // cost ratio of cost decrease / totalCost 
     
    36553616                        GlobalTerminationCriteriaMet(splitCandidate); 
    36563617 
    3657                 cout << "kd nodes: " << i ++ << endl; 
    3658  
    36593618                // cost ratio of cost decrease / totalCost 
    36603619                const float costRatio = splitCandidate->GetPriority() / mTotalCost; 
     3620                 
    36613621                //Debug << "cost ratio: " << costRatio << endl; 
     3622                //cout << "kd nodes: " << i ++ << endl; 
    36623623 
    36633624                if (costRatio < mTermMinGlobalCostRatio) 
  • GTP/trunk/Lib/Vis/Preprocessing/src/VspOspTree.h

    r1106 r1108  
    7272        virtual void EvalPriority() = 0; 
    7373        virtual int Type() const = 0; 
     74        virtual bool GlobalTerminationCriteriaMet() const = 0; 
    7475}; 
    7576 
     
    554555        {   
    555556        public: 
     557 
    556558                static VspTree* sVspTree; 
     559 
    557560                /// parent node traversal data 
    558561                VspTraversalData mParentData; 
     
    566569                { 
    567570                        sVspTree->EvalSplitCandidate(*this);     
     571                } 
     572 
     573                bool GlobalTerminationCriteriaMet() const 
     574                { 
     575                        return sVspTree->GlobalTerminationCriteriaMet(mParentData); 
    568576                } 
    569577 
     
    969977 
    970978        void ProcessViewCellObjects(ViewCell *parent, ViewCell *front, ViewCell *back) const; 
     979 
     980        void CreateViewCell(VspTraversalData &tData); 
    971981 
    972982protected: 
     
    11691179                } 
    11701180 
     1181                bool GlobalTerminationCriteriaMet() const 
     1182                { 
     1183                        return sOspTree->GlobalTerminationCriteriaMet(mParentData); 
     1184                } 
     1185 
     1186 
    11711187                OspSplitCandidate(const AxisAlignedPlane &plane, const OspTraversalData &tData):  
    11721188                SplitCandidate(plane), mParentData(tData) 
     
    13791395                @returns the root of the subdivision 
    13801396        */ 
    1381         KdInterior *SubdivideNode(KdLeaf *leaf, 
     1397        KdInterior *SubdivideNode( 
    13821398                const AxisAlignedPlane &splitPlane, 
    1383                 const AxisAlignedBox3 &box, 
     1399                const OspTraversalData &tData, 
    13841400                OspTraversalData &frontData, 
    13851401                OspTraversalData &backData); 
Note: See TracChangeset for help on using the changeset viewer.