source: GTP/trunk/Lib/Vis/Preprocessing/src/IntelRayCaster.cpp @ 2076

#include "IntelRayCaster.h"
#include "VssRay.h"
#include "Preprocessor.h"
#include "SceneGraph.h"

#ifdef GTP_INTERNAL
#include "ArchModeler2MLRT.hxx"

#define DEBUG_RAYCAST 0


namespace GtpVisibilityPreprocessor {


IntelRayCaster::IntelRayCaster(const Preprocessor &preprocessor, 
                                                           const string externKdTree):
RayCaster(preprocessor)
{
        if (!InitRayCast(externKdTree))
                cout << "warning: intel ray tracer could not be initialized!" << endl;
}


IntelRayCaster::~IntelRayCaster()
{
}


bool IntelRayCaster::InitRayCast(const string externKdTree)
{
        cout<<"Intel ray cast file: " << externKdTree << endl;
        
        return mlrtaLoadAS(externKdTree.c_str());
}


int IntelRayCaster::CastRay(
                                                        const SimpleRay &simpleRay,
                                                        VssRayContainer &vssRays,
                                                        const AxisAlignedBox3 &box,
                                                        const bool castDoubleRay,
                                                        const bool pruneInvalidRays
                                                        )
{
        //cout << "intel ray" << endl;
        VssRay *vssRay  = NULL;
        int hits = 0;
        int hittriangle;
        Intersection hitA(simpleRay.mOrigin), hitB(simpleRay.mOrigin);

        float dist;
        double normal[3];

        hittriangle = mlrtaIntersectAS(
                                                                   &simpleRay.mOrigin.x,
                                                                   &simpleRay.mDirection.x,
                                                                   normal,
                                                                   dist);
        
        if (hittriangle != -1 ) {
                Intersectable *intersect = mPreprocessor.GetParentObject(hittriangle);
                
                if (intersect)
                {
                        hitA.mObject = intersect;
                        hitA.mNormal = Vector3(normal[0], normal[1], normal[2]);
                        // Get the normal of that face
                        //              Mesh *mesh = ((MeshInstance *)objectA)->GetMesh();
                        //              normalA = mesh->GetFacePlane(mFaceParents[forward_hit_triangles[i]].mFaceIndex).mNormal;
                        //-rays[index+i].mDirection; // $$ temporary
                        hitA.mPoint = simpleRay.Extrap(dist);
                }
        }

        if (castDoubleRay)
        {
                Vector3 dir = -simpleRay.mDirection;
                hittriangle = mlrtaIntersectAS(
                                                                                &simpleRay.mOrigin.x,
                                                                                &dir.x,
                                                                                normal,
                                                                                dist);

                Intersectable *intersect = mPreprocessor.GetParentObject(hittriangle);
                
                if (intersect)
                {
                        hitB.mObject = intersect;
                        hitB.mNormal = Vector3(normal[0], normal[1], normal[2]);
                        // Get the normal of that face
                        //              Mesh *mesh = ((MeshInstance *)objectB)->GetMesh();
                        //              normalA = mesh->GetFacePlane(mFaceParents[forward_hit_triangles[i]].mFaceIndex).mNormal;
                        //-rays[index+i].mDirection; // $$ temporary
                        hitB.mPoint = simpleRay.Extrap(dist);
                }
        }

        return ProcessRay(
                                          simpleRay,
                                          hitA,
                                          hitB,
                                          vssRays,
                                          box,
                                          castDoubleRay,
                                          pruneInvalidRays
                                          );
}


void IntelRayCaster::CastRays16(
                                                                SimpleRayContainer &rays,
                                                                VssRayContainer &vssRays,
                                                                const AxisAlignedBox3 &sbox,
                                                                const bool castDoubleRay,
                                                                const bool pruneInvalidRays)
{
  CastRays16(rays, 0, vssRays, sbox, castDoubleRay, pruneInvalidRays);
}

void IntelRayCaster::CastRays16(
                                                                SimpleRayContainer &rays,
                                                                const int offset,
                                                                VssRayContainer &vssRays,
                                                                const AxisAlignedBox3 &sbox,
                                                                const bool castDoubleRay,
                                                                const bool pruneInvalidRays)
{
  int i, k;
  const int num = 16;
  
#if DEBUG_RAYCAST
  Debug<<"C16 "<<flush;
  static int counter=0;
  Debug<<counter++<<endl;
#endif
  
  static int forward_hit_triangles[16];
  static float forward_dist[16];
  
  static int backward_hit_triangles[16];
  static float backward_dist[16];
  
  
  Vector3 min = mPreprocessor.mSceneGraph->GetBox().Min();
  Vector3 max = mPreprocessor.mSceneGraph->GetBox().Max();

  for (k=offset, i=0; i < num; i++, k++) {
#if DEBUG_RAYCAST
        if (counter == 43964) {
          Debug<<rays[k].mOrigin<<" "<<rays[k].mDirection<<endl;
        }
#endif
        mlrtaStoreRayAS16(&rays[k].mOrigin.x,
                                          &rays[k].mDirection.x,
                                          i);
  }
  
#if DEBUG_RAYCAST
  Debug<<"TA\n"<<flush;
#endif
  
  mlrtaTraverseGroupAS16(&min.x,
                                                 &max.x,
                                                 forward_hit_triangles,
                                                 forward_dist);
  
#if DEBUG_RAYCAST
  Debug<<"TAB\n"<<flush;
#endif

  if (castDoubleRay) {
        for (k=offset, i=0; i < num; i++, k++)  {
          Vector3 dir = -rays[k].mDirection;
          mlrtaStoreRayAS16(&rays[k].mOrigin.x,
                                                &dir.x,
                                                i);
        }
        
#if DEBUG_RAYCAST
          Debug<<"TB\n"<<flush;
#endif
          
          mlrtaTraverseGroupAS16(&min.x,
                                                         &max.x,
                                                         backward_hit_triangles,
                                                         backward_dist);
        }
        
#if DEBUG_RAYCAST
        Debug<<"BBB\n"<<flush;
#endif
        
        for (i=0, k=offset; i < num; i++, k++) 
        {
                Intersection hitA(rays[k].mOrigin), hitB(rays[k].mOrigin);

#if DEBUG_RAYCAST
                Debug<<"FH\n"<<flush;
#endif

                Intersectable *intersect = mPreprocessor.GetParentObject(forward_hit_triangles[i]);

                if (intersect)
                {
                        hitA.mObject = intersect;
                        // Get the normal of that face
                        hitA.mNormal = mPreprocessor.GetParentNormal(forward_hit_triangles[i]);

                        //-rays[index+i].mDirection; // $$ temporary
                        hitA.mPoint = rays[k].Extrap(forward_dist[i]);
                }
        
#if DEBUG_RAYCAST
                Debug<<"BH\n"<<flush;
#endif

                if (castDoubleRay) 
                {
                        Intersectable *intersect = mPreprocessor.GetParentObject(backward_hit_triangles[i]);

                        if (intersect)
                        { 
                                hitB.mObject = intersect;
                                hitB.mNormal = mPreprocessor.GetParentNormal(backward_hit_triangles[i]);

                                // normalB = rays[i].mDirection; // $$ temporary
                                hitB.mPoint = rays[k].Extrap(-backward_dist[i]);
                        }
                }

#if DEBUG_RAYCAST
                Debug<<"PR\n"<<flush;
#endif

#if 1
                ProcessRay(rays[k],
                                   hitA,
                                   hitB,
                                   vssRays,
                                   sbox,
                                   castDoubleRay,
                                   pruneInvalidRays
                                   );
#endif
        }

#if DEBUG_RAYCAST
        Debug<<"C16F\n"<<flush;
#endif
}



void
IntelRayCaster::CastRays(
                                                 SimpleRayContainer &rays,
                                                 VssRayContainer &vssRays,
                                                 const AxisAlignedBox3 &sbox,
                                                 const bool castDoubleRay,
                                                 const bool pruneInvalidRays )
{
  cout<<"INTEL"<<endl;

  int buckets = rays.size()/16;
  int offset = 0;
  
  for (int i=0; i < buckets; i++, offset+=16) {
        CastRays16(rays, offset, vssRays, sbox, castDoubleRay, pruneInvalidRays);

        if ((int)rays.size() > 100000 && i % (100000/16) == 0)
          cout<<"\r"<<offset<<"/"<<(int)rays.size()<<"\r";
  }

  for (; offset < rays.size(); offset++)
        CastRay(rays[offset], vssRays, sbox, castDoubleRay, pruneInvalidRays);

}

}

#endif