Ignore:
Timestamp:
06/06/08 17:40:59 (16 years ago)
Author:
mattausch
Message:
 
File:
1 edited

Legend:

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

    r2741 r2742  
    140140 
    141141                // note: deletion of the ray is handled by ray pool 
     142                mRayCaster->SheduleRayForDeletion(ray); 
    142143        } 
    143144} 
     
    209210 
    210211        mGvsStats.mReverseSamples += (int)reverseRays.size(); 
    211  
    212212        EnqueueRays(reverseRays); 
    213213 
     
    234234        simpleRays.clear(); 
    235235 
    236         CreateRandomizedReverseRays(currentRay, predictedHit, simpleRays, 16); 
     236        CreateRandomizedReverseRays(currentRay, predictedHit, simpleRays, 16, hitTriangle); 
    237237 
    238238        static VssRayContainer reverseRays; 
     
    344344bool GvsPreprocessor::HandleRay(VssRay *vssRay) 
    345345{ 
    346         if (!vssRay || !HasContribution(*vssRay)) 
     346        if (!vssRay) 
    347347                return false; 
    348348 
     349        if (!HasContribution(*vssRay)) 
     350        { 
     351                mRayCaster->SheduleRayForDeletion(vssRay); 
     352                return false; 
     353        } 
     354         
    349355        if (0 && GVS_DEBUG) 
    350356                mVssRays.push_back(new VssRay(*vssRay)); 
     
    354360 
    355361        ++ mGvsStats.mTotalContribution; 
     362 
     363        if (mRayQueue.size() % 10000 == 0) 
     364                cout << "ray queue size: " << mRayQueue.size() << endl; 
     365 
     366        if (mGvsStats.mTotalContribution % 10000 == 0) 
     367                cout << "contri: " << mGvsStats.mTotalContribution << endl; 
    356368 
    357369        return true; 
     
    452464        // cast single ray to check if a triangle was missed. note: not efficient!! 
    453465        newRay = mRayCaster->CastRay(sray, mViewCellsManager->GetViewSpaceBox(), !mPerViewCell); 
     466        ++ castRays; 
     467         
    454468        castTimer.Exit(); 
    455469 
    456         ++ castRays; 
    457  
    458         // this ray will not be further processed 
    459         // note: ray deletion is handled by ray pool 
    460         if (!newRay) return castRays; 
    461  
    462         rayTimer.Entry(); 
    463  
    464         // new triangle discovered? => add new ray to queue 
    465         HandleRay(newRay); 
    466  
    467         rayTimer.Exit(); 
    468          
     470        if (!newRay) 
     471                return castRays; 
     472 
    469473        //newRay->mFlags |= VssRay::BorderSample; 
    470474 
    471475        // cast reverse rays if necessary 
    472         castRays += CheckDiscontinuity(ray2, hitTriangle, oldRay); 
    473  
     476        castRays += CheckDiscontinuity(*newRay, hitTriangle, oldRay); 
     477         
    474478        // subdivide further 
    475479        castRays += SubdivideEdge(hitTriangle, p1, p, ray1, *newRay, oldRay); 
    476480        castRays += SubdivideEdge(hitTriangle, p, p2, *newRay, ray2, oldRay); 
    477          
     481 
     482        rayTimer.Entry(); 
     483 
     484        // new triangle discovered? => add new ray to queue 
     485        HandleRay(newRay); 
     486 
     487        rayTimer.Exit(); 
     488 
    478489        return castRays; 
    479490} 
     
    549560        int castRays = (int)simpleRays.size(); 
    550561 
    551         // handle cast rays 
    552         EnqueueRays(vssRays); 
    553  
    554562        if (0) 
    555563        { 
     
    567575                        (*rit)->mFlags |= VssRay::BorderSample; 
    568576        } 
    569  
     577#if 0 
    570578    // recursivly subdivide each edge 
    571579        for (int i = 0; i < numBorderSamples; ++ i) 
     
    580588                                                                  currentRay); 
    581589        } 
    582          
     590#endif   
    583591        mGvsStats.mBorderSamples += castRays; 
    584592         
     593        // handle cast rays 
     594        EnqueueRays(vssRays); 
     595 
    585596        return castRays; 
    586597} 
     
    602613                cout << "error: gvs sampling for " << Intersectable::GetTypeName(tObj) << " not implemented" << endl; 
    603614 
     615         
     616        static SimpleRayContainer simpleRays; 
     617        simpleRays.clear(); 
     618         
     619 
    604620        generationTimer.Entry(); 
    605  
     621#if 0 
    606622        static VertexContainer enlargedTriangle; 
    607623        enlargedTriangle.clear(); 
     
    625641        } 
    626642 
    627         /// create rays from sample points and handle them 
    628         static SimpleRayContainer simpleRays; 
    629         simpleRays.clear(); 
    630          
    631643        VertexContainer::const_iterator vit, vit_end = subdivEnlargedTri.end(); 
    632644 
     
    639651        } 
    640652 
    641          
     653#endif   
    642654        ////////// 
    643655        //-- fill up simple rays with random rays so we can cast 16 rays at a time 
     
    675687        int castRays = (int)simpleRays.size(); 
    676688 
    677         // handle cast rays 
    678         EnqueueRays(vssRays); 
    679  
    680  
    681 #if 1 
     689#if 0 
    682690        for (size_t i = 0; i < vssRays.size(); ++ i) 
    683691        { 
     
    685693                castRays += CheckDiscontinuity2(*vssRays[i], hitTriangle, currentRay); 
    686694        } 
    687  
     695#endif 
     696#if 0 
    688697 
    689698    // recursivly subdivide each edge 
     
    702711 
    703712        mGvsStats.mBorderSamples += castRays; 
    704          
     713 
     714        // handle cast rays 
     715        EnqueueRays(vssRays); 
     716 
    705717        return castRays; 
    706718} 
     
    844856        else 
    845857        { 
    846                 GenerateRays(mUseDeterministicGvs ? numSamples : numSamples / 16, *mDistribution, simpleRays, sInvalidSamples); 
     858                GenerateRays(mUseDeterministicGvs ?  
     859                        numSamples : numSamples / 16, *mDistribution, simpleRays, sInvalidSamples); 
    847860        } 
    848861 
     
    883896 
    884897 
    885 void GvsPreprocessor::EnqueueRays(VssRayContainer &samples) 
     898void GvsPreprocessor::EnqueueRays(const VssRayContainer &samples) 
    886899{ 
    887900        rayTimer.Entry(); 
     
    893906                VssRay *ray = *vit; 
    894907                HandleRay(ray); 
    895                 // note: deletion of invalid samples handked by ray pool 
    896908        } 
    897909 
     
    918930                else 
    919931                        castSamples += AdaptiveBorderSamplingOpt(*ray); 
    920  
    921                 // note: don't have to delete because handled by ray pool 
    922932        } 
    923933 
     
    20012011void GvsPreprocessor::PrepareProbablyVisibleSampling() 
    20022012{ 
    2003          
    20042013        // warning: using mailing! 
    20052014        Intersectable::NewMail(); 
     
    20432052                                                                                                  const Vector3 &predictedPoint,  
    20442053                                                                                                  SimpleRayContainer &rays,  
    2045                                                                                                   int number) 
     2054                                                                                                  int number, 
     2055                                                                                                  const Triangle3 &triangle) 
    20462056{ 
    20472057        size_t currentNumber = rays.size(); 
     
    20522062        { 
    20532063                SimpleRay simpleRay; 
    2054                 if (CreateRandomizedReverseRay(ray, predictedPoint, simpleRay)) 
     2064                if (CreateRandomizedReverseRay(ray, predictedPoint, simpleRay, triangle)) 
    20552065                        rays.push_back(simpleRay); 
    20562066        } 
    20572067 
     2068        if (rays.size() != 16) 
     2069                cout << "x"; 
     2070        //else cout <<"y"; 
    20582071        //cout << "generated " << rays.size() << " rays" << endl; 
    20592072} 
     
    20622075bool GvsPreprocessor::CreateRandomizedReverseRay(const VssRay &ray,  
    20632076                                                                                                 const Vector3 &predictedPoint,  
    2064                                                                                                  SimpleRay &simpleRay) 
    2065 { 
    2066         //Vector3 nd = ray.GetNormalizedDir(); 
     2077                                                                                                 SimpleRay &simpleRay, 
     2078                                                                                                 const Triangle3 &triangle) 
     2079{ 
     2080        /*Vector3 nd = ray.GetNormalizedDir(); 
    20672081        const AxisAlignedBox3 box = mCurrentViewCell->GetBox(); 
    20682082        //Vector3 nd = box.GetNearestFace(origin).GetNormal(); 
     
    20702084 
    20712085        // Compute right handed coordinate system from direction 
    2072         /*Vector3 U, V; 
     2086        Vector3 U, V; 
    20732087        nd.RightHandedBase(U, V); 
    20742088         
     
    20792093 
    20802094        Vector2 vr2(rr[0], rr[1]); 
    2081         const float sigma = 1.0f;//triangle.GetBoundingBox().Radius() * mRadiusOfInfluence; 
     2095        const float sigma = triangle.GetBoundingBox().Radius() * 1.0f; 
    20822096        Vector2 gaussvec2; 
    20832097 
    20842098        GaussianOn2D(vr2, sigma, // input 
    20852099                         gaussvec2); // output 
    2086          
    2087         const Vector3 shift = gaussvec2.xx * U + gaussvec2.yy * V; 
    2088  
    2089         Vector3 newOrigin = ray.mOrigin + shift; 
    20902100        */ 
     2101        const Vector3 shift = 0;//gaussvec2.xx * U + gaussvec2.yy * V; 
     2102 
     2103        const Vector3 newTermination = ray.mTermination + shift; 
     2104         
    20912105        //cout << "o: " << origin << " new o: " << newOrigin << endl; 
    2092         Vector3 newOrigin = box.GetRandomPoint(); 
    2093         Vector3 direction = predictedPoint - newOrigin; 
     2106        Vector3 newOrigin = mCurrentViewCell->GetBox().GetRandomPoint(); 
     2107        Vector3 direction = newTermination - newOrigin; 
    20942108 
    20952109        const float len = Magnitude(direction); 
     
    21012115 
    21022116        if (0 && !IntersectsViewCell(newOrigin, -direction)) 
    2103         { 
    2104                 //cout << "x"; 
    21052117                return false; 
    2106         } 
    21072118 
    21082119        //cout << "y"; 
     
    21142125} 
    21152126 
    2116  
    2117 } 
     2127} 
Note: See TracChangeset for help on using the changeset viewer.