source: GTP/trunk/Lib/Vis/Preprocessing/src/RayCaster.cpp @ 1932

#include "RayCaster.h"
#include "VssRay.h"
#include "Ray.h"
#include "Preprocessor.h"


namespace GtpVisibilityPreprocessor {


#define DEBUG_RAYCAST 0

#define EXACT_BOX_CLIPPING 1

RayCaster::RayCaster(const Preprocessor &preprocessor):
mPreprocessor(preprocessor)
{
}


RayCaster::~RayCaster()
{
}


VssRay *RayCaster::CastRay(const SimpleRay &simpleRay,
                                                   const AxisAlignedBox3 &box)
                                                   //const bool castDoubleRay) 
{
        // note: make no sense otherwise
        const bool castDoubleRay = false;
        VssRayContainer rays;
        CastRay(simpleRay, rays, box, castDoubleRay);
    
        if (!rays.empty())
                return rays.back();
        else
                return NULL;
}


/** Checks if ray is valid, (e.g., not in empty view space or outside the view space)
*/
bool
RayCaster::ValidateRay(const Vector3 &origin,
                                           const Vector3 &direction,
                                           const AxisAlignedBox3 &box,
                                           Intersection &hit)
{
        if (!hit.mObject)  
        {
                // compute intersection with the scene bounding box
#if EXACT_BOX_CLIPPING
                static Ray ray;
                mPreprocessor.SetupRay(ray, origin, direction);

                float tmin, tmax;
                if (box.ComputeMinMaxT(ray, &tmin, &tmax) && (tmin < tmax)) 
                {
                        hit.mPoint = ray.Extrap(tmax);
                }
                else 
                {
                        // cout<<" invalid hp "<<tmin<<" "<<tmax<<endl;
                        // cout<<" box "<<box<<endl;
                        // cout<<" origin "<<origin<<endl;
                        // cout<<" direction "<<direction<<endl;
                        // cout<< "inv dir"<<ray.GetInvDir()<<endl;
                        return false;
                }
#else
                hit.mPoint = origin + direction * Magnitude(box.Diagonal());
#endif
        }
        else
        {
                if (mPreprocessor.mDetectEmptyViewSpace) 
                {
                        if (DotProd(hit.mNormal, direction) >= -Limits::Small) 
                        {       
                                hit.mObject = NULL;
                                return false;
                        }
                }
        }

        return true;
}


int
RayCaster::ProcessRay(const SimpleRay &simpleRay,
                                          Intersection &hitA,
                                          Intersection &hitB,
                                          VssRayContainer &vssRays,
                                          const AxisAlignedBox3 &box,
                                          const bool castDoubleRay,
                                          const bool pruneInvalidRays)
{
        int hits = 0;

#if DEBUG_RAYCAST
        Debug<<"PRA"<<flush;
#endif

        // regardless of the pruneInvalidRays setting reject rays whic degenerate to a point
        //      if (EpsilonEqualV3(hitA.mPoint, hitB.mPoint, Limits::Small))
        //        return 0;
        
        if (pruneInvalidRays) 
        {
                if (!hitA.mObject && !hitB.mObject) 
                {
                        return 0;
                }
        }
        
        const bool validA = 
          ValidateRay(simpleRay.mOrigin, simpleRay.mDirection, box, hitA);
        
        // note: should we check for backward valitidy also for single rays?
        const bool validB = //castDoubleRay && 
                ValidateRay(simpleRay.mOrigin, -simpleRay.mDirection, box, hitB);
        
#if DEBUG_RAYCAST
        Debug<<"PR1"<<flush;
#endif
        
        // reset both contributions
        if (!validA || !validB)
        {
                if (pruneInvalidRays)
                        return 0;
                
                // reset both contributions of this ray
                hitA.mObject = NULL;
                hitB.mObject = NULL;
        }
          
        // 8.11. 2007 JB
        // degenerate rays checked by geometrical constraint...
        //      !pruneInvalidRays || (hitA.mObject != hitB.mObject);
        
#if DEBUG_RAYCAST
        Debug<<"PR2"<<flush;
#endif

        if (!pruneInvalidRays || hitA.mObject) 
        {
                VssRay *vssRay = new VssRay(hitB.mPoint,
                                                                        hitA.mPoint,
                                                                        hitB.mObject,
                                                                        hitA.mObject,
                                                                        mPreprocessor.mPass,
                                                                        simpleRay.mPdf);

                if (validA)
                        vssRay->mFlags |= VssRay::Valid;

                vssRay->mDistribution = simpleRay.mDistribution;
                vssRays.push_back(vssRay);
                ++ hits;
                //cout << "vssray 1: " << *vssRay << " " << vssRay->mTermination - vssRay->mOrigin << endl;
        }

#if DEBUG_RAYCAST
        Debug<<"PR3"<<flush;
#endif

        if (castDoubleRay && (!pruneInvalidRays || hitB.mObject))
        {
                VssRay *vssRay = new VssRay(hitA.mPoint,
                                                                        hitB.mPoint,
                                                                        hitA.mObject,
                                                                        hitB.mObject,
                                                                        mPreprocessor.mPass,
                                                                        simpleRay.mPdf);

                if (validB)
                        vssRay->mFlags |= VssRay::Valid;

                vssRay->mDistribution = simpleRay.mDistribution;
                vssRays.push_back(vssRay);
                ++ hits;
                //cout << "vssray 2: " << *vssRay << endl;
        }
        
#if DEBUG_RAYCAST
        Debug<<"PR4"<<flush;
#endif

        return hits;
}

}