Changeset 1520 for GTP/trunk/Lib

Timestamp:

09/27/06 16:24:39 (18 years ago)

Author:

mattausch

Message:

moved raycasting out of preprocessor into specific ray casting interface

Location:

GTP/trunk/Lib/Vis/Preprocessing/src

Files:

• Environment.cpp (modified) (1 diff)
• GvsPreprocessor.cpp (modified) (2 diffs)
• IntelRayCaster.cpp (added)
• IntelRayCaster.h (added)
• InternalRayCaster.cpp (added)
• InternalRayCaster.h (added)
• Preprocessor.cpp (modified) (11 diffs)
• Preprocessor.h (modified) (10 diffs)
• Preprocessor.vcproj (modified) (3 diffs)
• QtGlRenderer/QtGlRenderer.vcproj (modified) (1 diff)
• QtPreprocessorThread.cpp (modified) (3 diffs)
• RayCaster.cpp (added)
• RayCaster.h (added)
• RssPreprocessor.cpp (modified) (9 diffs)
• SamplingPreprocessor.cpp (modified) (2 diffs)
• SamplingStrategy.cpp (modified) (3 diffs)
• SamplingStrategy.h (modified) (1 diff)
• ViewCellsManager.cpp (modified) (7 diffs)

GTP/trunk/Lib/Vis/Preprocessing/src/Environment.cpp

@@ -1281 +1281 @@
 
 
+
   /***********************************************************************************/
   /*                         View cells related options                              */

GTP/trunk/Lib/Vis/Preprocessing/src/GvsPreprocessor.cpp

@@ -198 +198 @@
         // establish visibility
         VssRayContainer vssRays;
-        CastRays(simpleRays, vssRays);
+        CastRays(simpleRays, vssRays, false);
         // add to ray queue
         EnqueueRays(vssRays);
@@ -273 +273 @@
         // generate vss rays
         VssRayContainer samples;
-        CastRays(simpleRays, samples);
+        CastRays(simpleRays, samples, true);
         
         // add to ray queue

GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.cpp

@@ -19 +19 @@
 #include "HierarchyManager.h"
 #include "VssRay.h"
-
-
-#ifdef GTP_INTERNAL
-#include "ArchModeler2MLRT.hxx"
-#endif
+#include "IntelRayCaster.h"
+#include "InternalRayCaster.h"
+
+
 
 #define DEBUG_RAYCAST 0
@@ -31 +30 @@
 
 const static bool ADDITIONAL_GEOMETRY_HACK = false;
-
-//Preprocessor *preprocessor;
 
 
@@ -135 +132 @@
 mRenderSimulator(NULL),
 mPass(0),
-mRayCastMethod(0),
-mSceneGraph(NULL)
+mSceneGraph(NULL),
+mRayCaster(NULL)
 {
         Environment::GetSingleton()->GetBoolValue("Preprocessor.useGlRenderer", mUseGlRenderer);
@@ -149 +146 @@
         Environment::GetSingleton()->GetBoolValue("Preprocessor.detectEmptyViewSpace", mDetectEmptyViewSpace);
         Environment::GetSingleton()->GetBoolValue("Preprocessor.exportVisibility", mExportVisibility );
-        Environment::GetSingleton()->GetIntValue("Preprocessor.rayCastMethod", mRayCastMethod);
-
+        
         char buffer[256];
         Environment::GetSingleton()->GetStringValue("Preprocessor.visibilityFile",  buffer);
@@ -162 +158 @@
         Debug << "detect empty view space=" << mDetectEmptyViewSpace << endl;
         Debug << "load meshes: " << mLoadMeshes << endl;
-
-        if (mRayCastMethod == 0)
-                cout << "ray cast method: internal" << endl;
-        else
-                cout << "ray cast method: intel" << endl;
 }
 
@@ -237 +228 @@
 
         // intel ray caster can only trace triangles
-        vector<FaceParentInfo> *fi = (mRayCastMethod == Preprocessor::INTEL_RAYCASTER) ?
+        int rayCastMethod;
+        Environment::GetSingleton()->GetIntValue("Preprocessor.rayCastMethod", rayCastMethod);
+        vector<FaceParentInfo> *fi = (rayCastMethod == RayCaster::INTEL_RAYCASTER) ?
                 &mFaceParents : NULL;
 
@@ -759 +752 @@
         switch (strategyId)
         {
-        case OBJECT_BASED_DISTRIBUTION: 
+        case SamplingStrategy::OBJECT_BASED_DISTRIBUTION: 
                 return new ObjectBasedDistribution(*this);
-        case OBJECT_DIRECTION_BASED_DISTRIBUTION:
+        case SamplingStrategy::OBJECT_DIRECTION_BASED_DISTRIBUTION:
                 return new ObjectDirectionBasedDistribution(*this);
-        case DIRECTION_BASED_DISTRIBUTION:
+        case SamplingStrategy::DIRECTION_BASED_DISTRIBUTION:
                 return new DirectionBasedDistribution(*this);
-        case DIRECTION_BOX_BASED_DISTRIBUTION: 
+        case SamplingStrategy::DIRECTION_BOX_BASED_DISTRIBUTION: 
                 return new DirectionBoxBasedDistribution(*this);
-        case SPATIAL_BOX_BASED_DISTRIBUTION:
+        case SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION:
                 return new SpatialBoxBasedDistribution(*this);
         //case OBJECTS_INTERIOR_DISTRIBUTION:
@@ -819 +812 @@
         }
 
-        switch (mRayCastMethod) // use intel ray tracing
-        {
-        case INTEL_RAYCASTER:
-#ifdef GTP_INTERNAL
-          cout<<"Ray Cast file: " << externKdTree << endl;
-          return mlrtaLoadAS(externKdTree.c_str());
-#endif
-        case INTERNAL_RAYCASTER:
-        default:
-                break;
+        int rayCastMethod;
+        Environment::GetSingleton()->GetIntValue("Preprocessor.rayCastMethod", rayCastMethod);
+
+        if (rayCastMethod == 0)
+        {
+                mRayCaster = new InternalRayCaster(*this, mKdTree);
+                cout << "ray cast method: internal" << endl;
+        }
+        else
+        {
+                mRayCaster = new IntelRayCaster(*this, externKdTree);
+                cout << "ray cast method: intel" << endl;
         }
 
@@ -834 +829 @@
 }
 
-
-int Preprocessor::CastIntelDoubleRay(
-                                                                         const Vector3 &viewPoint,
-                                                                         const Vector3 &direction,
-                                                                         const float probability,
-                                                                         VssRayContainer &vssRays,
-                                                                         const AxisAlignedBox3 &box
-                                                                         )
-{
-#ifdef GTP_INTERNAL
-        //cout << "intel ray" << endl;
-        VssRay *vssRay  = NULL;
-        int hits = 0;
-        int hittriangle;
-        Vector3 pointA, pointB;
-        Vector3 normalA, normalB;
-        Intersectable *objectA = NULL, *objectB = NULL;
-        float dist;
-        double normal[3];
-
-        hittriangle = mlrtaIntersectAS(&viewPoint.x,
-                &direction.x,
-                normal,
-                dist);
-
-        if (hittriangle != -1 ) {
-                if (hittriangle >= mFaceParents.size())
-                        cerr<<"Warning: triangle index out of range! "<<hittriangle<<endl;
-                else {
-                        objectA = mFaceParents[hittriangle].mObject;
-                        normalA = 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
-                        pointA = viewPoint + direction*dist;
-                }
-        }
-
-
-        Vector3 dir = -direction;
-        hittriangle = mlrtaIntersectAS(&viewPoint.x,
-                &dir.x,
-                normal,
-                dist);
-
-        if (hittriangle != -1 ) {
-                if (hittriangle >= mFaceParents.size())
-                        cerr<<"Warning: triangle index out of range! "<<hittriangle<<endl;
-                else {
-                        objectB = mFaceParents[hittriangle].mObject;
-                        normalB = 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
-                        pointB = viewPoint + dir * dist;
-                }
-        }
-
-        return ProcessRay(viewPoint,
-                direction,
-                objectA, pointA, normalA,
-                objectB, pointB, normalB,
-                probability,
-                vssRays,
-                box
-                );
-#else
-        return -1;
-#endif
-}
-
-
-Intersectable *Preprocessor::CastIntelSingleRay(const Vector3 &viewPoint,
-                                                                                                const Vector3 &direction,
-                                                                                                //const float probability,
-                                                                                                Vector3 &tPoint,
-                                                                                                const AxisAlignedBox3 &box
-                                                                                                )
-{
-        AxisAlignedBox3 sbox = box;
-        sbox.Enlarge(Vector3(-Limits::Small));
-
-        if (!sbox.IsInside(viewPoint))
-                return 0;
-        
-#ifdef GTP_INTERNAL
-        float pforg[3];
-        float pfdir[3];
-        double pfnorm[3];
-
-        pforg[0] = viewPoint[0]; pforg[1] = viewPoint[1]; pforg[2] = viewPoint[2];
-        pfdir[0] = direction[0]; pfdir[1] = direction[1]; pfdir[2] = direction[2];
-
-        float dist;
-        const int hittriangle = mlrtaIntersectAS(pforg, pfdir, pfnorm, dist);
-
-        if (hittriangle == -1)
-          {
-                static Ray ray;
-                SetupRay(ray, viewPoint, direction);
-                
-                float tmin = 0, tmax;
-                if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
-                  {
-                        tPoint = ray.Extrap(tmax);
-                  }
-                
-                return NULL;
-          }
-        else {
-          if (hittriangle >= mFaceParents.size()) {
-                cerr<<"Warning: triangle index out of range! "<<hittriangle<<endl;
-                return NULL;
-          }
-          else {
-                
-                tPoint[0] = pforg[0] + pfdir[0] * dist;
-                tPoint[1] = pforg[1] + pfdir[1] * dist;
-                tPoint[2] = pforg[2] + pfdir[2] * dist;
-                
-                return mFaceParents[hittriangle].mObject;
-          }
-        }
-
-#else
-        const int hittriangle = -1;
-        return NULL;
-#endif
-
-}
-
-
-int Preprocessor::CastInternalRay(
-                                                                  const Vector3 &viewPoint,
-                                                                  const Vector3 &direction,
-                                                                  const float probability,
-                                                                  VssRayContainer &vssRays,
-                                                                  const AxisAlignedBox3 &box
-                                                                  )
-{
-  //cout << "internal ray" << endl;
-  int hits = 0;
-  static Ray ray;
-  Intersectable *objectA, *objectB;
-  Vector3 pointA, pointB;
-
-  //  AxisAlignedBox3 box = Union(mKdTree->GetBox(), mViewCellsManager->GetViewSpaceBox());
-  AxisAlignedBox3 sbox = box;
-  sbox.Enlarge(Vector3(-Limits::Small));
-  if (!sbox.IsInside(viewPoint))
-        return 0;
-        
-  SetupRay(ray, viewPoint, direction);
-  ray.mFlags &= ~Ray::CULL_BACKFACES;
-
-  // cast ray to KD tree to find intersection with other objects
-  float bsize = Magnitude(box.Size());
-  
-  
-  if (mKdTree->CastRay(ray)) {
-        objectA = ray.intersections[0].mObject;
-        pointA = ray.Extrap(ray.intersections[0].mT);
-        if (mDetectEmptyViewSpace)
-          if (DotProd(ray.intersections[0].mNormal, direction) >= 0) {
-                // discard the sample
-                return 0;
-          }
-        
-  } else {
-        objectA = NULL;
-        // compute intersection with the scene bounding box
-        float tmin, tmax;
-        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
-          pointA = ray.Extrap(tmax);
-        else
-          return 0;
-  }
-
-  SetupRay(ray, viewPoint, -direction);
-  ray.mFlags &= ~Ray::CULL_BACKFACES;
-  
-  if (mKdTree->CastRay(ray)) {
-        objectB = ray.intersections[0].mObject;
-        pointB = ray.Extrap(ray.intersections[0].mT);
-        if (mDetectEmptyViewSpace)
-          if (DotProd(ray.intersections[0].mNormal, direction) <= 0) {
-                // discard the sample
-                return 0;
-          }
-  } else {
-        objectB = NULL;
-        float tmin, tmax;
-        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
-          pointB = ray.Extrap(tmax);
-        else
-          return 0;
-  }
-  
-  
-  VssRay *vssRay  = NULL;
-  bool validSample = (objectA != objectB);
-  if (validSample) {
-        if (objectA) {
-          vssRay = new VssRay(pointB,
-                                                  pointA,
-                                                  objectB,
-                                                  objectA,
-                                                  mPass,
-                                                  probability
-                                                  );
-          vssRays.push_back(vssRay);
-          //cout << "ray: " << *vssRay << endl;
-          hits ++;
-        }
-        
-        if (objectB) {
-          vssRay = new VssRay(pointA,
-                                                  pointB,
-                                                  objectA,
-                                                  objectB,
-                                                  mPass,
-                                                  probability
-                                                  );
-          vssRays.push_back(vssRay);
-          //cout << "ray: " << *vssRay << endl;
-          hits ++;
-        }
-  }
-  
-  return hits;
-}
-
-
-int
-Preprocessor::ProcessRay(
-                                                 const Vector3 &viewPoint,
-                                                 const Vector3 &direction,
-                                                 Intersectable *objectA,
-                                                 Vector3 &pointA,
-                                                 const Vector3 &normalA,
-                                                 Intersectable *objectB,
-                                                 Vector3 &pointB,
-                                                 const Vector3 &normalB,
-                                                 const float probability,
-                                                 VssRayContainer &vssRays,
-                                                 const AxisAlignedBox3 &box
-                                                 )
-{
-  int hits=0;
-#if DEBUG_RAYCAST
-  Debug<<"PR ";
-#endif
-  if (objectA == NULL && objectB == NULL)
-        return 0;
-  
-  AxisAlignedBox3 sbox = box;
-  sbox.Enlarge(Vector3(-Limits::Small));
-
-  if (!sbox.IsInside(viewPoint))
-        return 0;
-
-  if (objectA == NULL) {
-        // compute intersection with the scene bounding box
-        static Ray ray;
-        SetupRay(ray, viewPoint, direction);
-        
-        float tmin, tmax;
-        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
-          pointA = ray.Extrap(tmax);
-        else
-          return 0;
-  } else {
-        if (mDetectEmptyViewSpace)
-          if (DotProd(normalA, direction) >= 0) {
-                // discard the sample
-                return 0;
-          }
-  }
-
-  if (objectB == NULL) {
-        // compute intersection with the scene bounding box
-        static Ray ray;
-        SetupRay(ray, viewPoint, -direction);
-
-        float tmin, tmax;
-        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
-          pointB = ray.Extrap(tmax);
-        else
-          return 0;
-  } else {
-        if (mDetectEmptyViewSpace)
-          if (DotProd(normalB, direction) <= 0) {
-                // discard the sample
-                return 0;
-          }
-  }
-  
-  VssRay *vssRay  = NULL;
-  bool validSample = (objectA != objectB);
-  if (validSample) {
-        if (objectA) {
-          vssRay = new VssRay(pointB,
-                                                  pointA,
-                                                  objectB,
-                                                  objectA,
-                                                  mPass,
-                                                  probability
-                                                  );
-          vssRays.push_back(vssRay);
-          //cout << "ray: " << *vssRay << endl;
-          hits ++;
-        }
-        
-        if (objectB) {
-          vssRay = new VssRay(pointA,
-                                                  pointB,
-                                                  objectA,
-                                                  objectB,
-                                                  mPass,
-                                                  probability
-                                                  );
-          vssRays.push_back(vssRay);
-          //cout << "ray: " << *vssRay << endl;
-          hits ++;
-        }
-  }
-
-
-  return hits;
-}
-
-void
-Preprocessor::CastRays16(const int index,
-                                                 SimpleRayContainer &rays, 
-                                                 VssRayContainer &vssRays,
-                                                 const AxisAlignedBox3 &sbox)
-{
-  int i;
-  const int num = 16;
-
-#if DEBUG_RAYCAST
-  Debug<<"C16 "<<flush;
-#endif
-  if (mRayCastMethod == INTEL_RAYCASTER) {
-#ifdef GTP_INTERNAL
-
-  int forward_hit_triangles[16];
-  float forward_dist[16];
-
-  int backward_hit_triangles[16];
-  float backward_dist[16];
-
-
-  Vector3 min = sbox.Min();
-  Vector3 max = sbox.Max();
-  
-  for (i=0; i < num; i++) {
-        mlrtaStoreRayAS16(&rays[index + i].mOrigin.x,
-                                          &rays[index + i].mDirection.x,
-                                          i);
-  }
-  
-  mlrtaTraverseGroupAS16(&min.x,
-                                                 &max.x,
-                                                 forward_hit_triangles,
-                                                 forward_dist);
-
-  for (i=0; i < num; i++) {
-        Vector3 dir = -rays[index + i].mDirection;
-        mlrtaStoreRayAS16(&rays[index+i].mOrigin.x,
-                                          &dir.x,
-                                          i);
-  }
-  
-  mlrtaTraverseGroupAS16(&min.x,
-                                                 &max.x,
-                                                 backward_hit_triangles,
-                                                 backward_dist);
-  
-
-  for (i=0; i < num; i++) {
-        Intersectable *objectA = NULL, *objectB = NULL;
-        Vector3 pointA, pointB;
-        Vector3 normalA, normalB;
-
-        if (forward_hit_triangles[i] != -1 ) {
-          if (forward_hit_triangles[i] >= mFaceParents.size())
-                cerr<<"Warning: triangle index out of range! "<<forward_hit_triangles[i]<<endl;
-          else { 
-                objectA = mFaceParents[forward_hit_triangles[i]].mObject;
-                // Get the normal of that face
-                normalA = objectA->GetNormal(mFaceParents[forward_hit_triangles[i]].mFaceIndex);
-                //-rays[index+i].mDirection; // $$ temporary
-                pointA = rays[index+i].Extrap(forward_dist[i]);
-          }
-        }
-         
-        if (backward_hit_triangles[i]!=-1) {
-          if (backward_hit_triangles[i] >= mFaceParents.size())
-                cerr<<"Warning: triangle  index out of range! "<<backward_hit_triangles[i]<<endl;
-          else { 
-                objectB = mFaceParents[backward_hit_triangles[i]].mObject;
-                normalB = objectB->GetNormal(mFaceParents[forward_hit_triangles[i]].mFaceIndex);
-                
-                // normalB = rays[index+i].mDirection; // $$ temporary
-                pointB = rays[index+i].Extrap(-backward_dist[i]);
-          }
-        }
- 
-        ProcessRay(rays[index+i].mOrigin,
-                           rays[index+i].mDirection,
-                           objectA, pointA, normalA,
-                           objectB, pointB, normalB,
-                           rays[index+i].mPdf,
-                           vssRays,
-                           sbox
-                           );
-  }
-  
-#endif
-  
-  } else {
-
-        for (i=index; i < index + num; i++) {
-          CastRay(rays[i].mOrigin,
-                          rays[i].mDirection,
-                          rays[i].mPdf,
-                          vssRays,
-                          sbox);
-        }
-  }
-#if DEBUG_RAYCAST
-  Debug<<"C16F\n"<<flush;
-#endif
-}
 
 void
 Preprocessor::CastRays(
                                            SimpleRayContainer &rays,
-                                           VssRayContainer &vssRays
+                                           VssRayContainer &vssRays,
+                                           const bool castDoubleRays
                                            )
 {
-  long t1 = GetTime();
-  
-  for (int i = 0; i < (int)rays.size(); ) {
-          // method only available for intel raycaster yet
-        if (i + 16 < (int)rays.size()) {
-
-          CastRays16(
-                                 i,
-                                 rays,
-                                 vssRays,
-                                 mViewCellsManager->GetViewSpaceBox());
-          i += 16;
-        } else {
-          CastRay(rays[i].mOrigin,
-                          rays[i].mDirection,
-                          rays[i].mPdf,
-                          vssRays,
-                          mViewCellsManager->GetViewSpaceBox());
-          i++;
-        }
-        if (i % 10000 == 0)
-          cout<<".";
-  }
-
-  long t2 = GetTime();
-  cout<<2*rays.size()/(1e3*TimeDiff(t1, t2))<<"M rays/s"<<endl;
-}
-
-Intersectable *
-Preprocessor::CastSimpleRay(
-                                                        const Vector3 &viewPoint,
-                                                        const Vector3 &direction,
-                                                        const AxisAlignedBox3 &box,
-                                                        Vector3 &point,
-                                                        Vector3 &normal
-                                                        )
-{
-  Intersectable *result = NULL;
-  switch (mRayCastMethod)
-        {
-        case INTEL_RAYCASTER: {
-         
-          int hittriangle;
-
-#ifdef GTP_INTERNAL
-          float dist; 
-          double n[3];
-
-          hittriangle = mlrtaIntersectAS(&viewPoint.x,
-                                                                         &direction.x,
-                                                                         n,
-                                                                         dist);
-
-           if (hittriangle !=-1 ) {
-                if (hittriangle >= mFaceParents.size())
-                  cerr<<"Warning: triangle index out of range! "<<hittriangle<<endl;
-                else {
-                  result = mFaceParents[hittriangle].mObject;
-                  normal = Vector3(n[0], n[1], n[2]);
-                  point = viewPoint + direction*dist;
-                }
-          }
-#else
-          hittriangle = -1;
-#endif
-
-          break;
-        }
-        case INTERNAL_RAYCASTER:
-        default: {
-          static Ray ray;
-          
-          ray.intersections.clear();
-          // do not store anything else then intersections at the ray
-          ray.Init(viewPoint, direction, Ray::LOCAL_RAY);
-          
-          ray.mFlags &= ~Ray::CULL_BACKFACES;
-          
-          if (mKdTree->CastRay(ray)) {
-                result = ray.intersections[0].mObject;
-                point = ray.Extrap(ray.intersections[0].mT);
-                normal = ray.intersections[0].mNormal;
-          }
-          break;
-        }
-        }
-  return result;
-}
-
-int
-Preprocessor::CastRay(
-                                          const Vector3 &viewPoint,
-                                          const Vector3 &direction,
-                                          const float probability,
-                                          VssRayContainer &vssRays,
-                                          const AxisAlignedBox3 &box
-                                          )
-{
-#if DEBUG_RAYCAST
-  Debug<<"CR "<<flush;
-#endif
-  switch (mRayCastMethod)
-        {
-        case INTEL_RAYCASTER:
-                return CastIntelDoubleRay(viewPoint, direction, probability, vssRays, box);
-        case INTERNAL_RAYCASTER:
-        default:
-                return CastInternalRay(viewPoint, direction, probability, vssRays, box);
-        }
-#if DEBUG_RAYCAST       
-  Debug<<"CRF "<<flush;
-#endif  
+        long t1 = GetTime();
+
+        if (castDoubleRays)
+        {
+                for (int i = 0; i < (int)rays.size(); ) 
+                {
+                        if (i + 16 < (int)rays.size()) 
+                        {
+                                mRayCaster->CastRays16(
+                                        i,
+                                        rays,                           
+                                        vssRays,
+                                        mViewCellsManager->GetViewSpaceBox(),
+                                        castDoubleRays);
+                                i += 16;
+                        } 
+                        else 
+                        {
+                                mRayCaster->CastRay(
+                                        rays[i].mOrigin,
+                                        rays[i].mDirection,
+                                        rays[i].mPdf,
+                                        vssRays,
+                                        mViewCellsManager->GetViewSpaceBox(),
+                                        castDoubleRays);
+                                i++;
+                        }
+                        
+                        if (i % 10000 == 0)
+                                cout<<".";
+                }
+
+                long t2 = GetTime();
+
+                if (castDoubleRays)
+                        cout << 2 * rays.size() / (1e3f * TimeDiff(t1, t2)) << "M rays/s" << endl;
+                else
+                        cout << rays.size() / (1e3f * TimeDiff(t1, t2)) << "M rays/s" << endl;
+        }
+        
 }
 
@@ -1429 +916 @@
                                                         const Vector3 &point,
                                                         const Vector3 &direction
-                                                        )
+                                                        ) const
 {
         ray.Clear();
@@ -1436 +923 @@
 }
 
-}
+
+}

GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.h

@@ -8 +8 @@
 #include "KdTree.h"
 
-// matt: remove qt dependencies
-//#include <QObject>
+
 
 namespace GtpVisibilityPreprocessor {
@@ -29 +28 @@
 class Intersectable;
 class VssRay;
+class RayCaster;
+
 
 /** Namespace for the external visibility preprocessor
@@ -45 +46 @@
 {
   //Q_OBJECT
-
+        friend class RayCaster;
+        friend class IntelRayCaster;
+        friend class InternalRayCaster;
+        
 public:
         /** Default constructor initialising e.g., KD tree and BSP tree.
@@ -51 +55 @@
         Preprocessor();
 
-   virtual ~Preprocessor();
+        virtual ~Preprocessor();
 
   /** Load the input scene. 
@@ -123 +127 @@
   bool ExportKdTree(const string filename);
 
-  /** Get Sample rays of particular type, returns false if this
-          type of rays is not supported by the preprocessor
-  */
-  enum {
-        OBJECT_BASED_DISTRIBUTION,
-        DIRECTION_BASED_DISTRIBUTION,
-        DIRECTION_BOX_BASED_DISTRIBUTION,
-        SPATIAL_BOX_BASED_DISTRIBUTION,
-        RSS_BASED_DISTRIBUTION,
-        RSS_SILHOUETTE_BASED_DISTRIBUTION,
-        VSS_BASED_DISTRIBUTION,
-        OBJECT_DIRECTION_BASED_DISTRIBUTION,
-        OBJECTS_INTERIOR_DISTRIBUTION
-  };
-  
-  enum {
-          INTERNAL_RAYCASTER = 0,
-          INTEL_RAYCASTER
-  };
-
   virtual bool
   GenerateRays(
@@ -157 +141 @@
 
   virtual void CastRays(SimpleRayContainer &rays,
-                                                VssRayContainer &vssRays);
+                                                VssRayContainer &vssRays,
+                                                const bool castDoubleRays);
 
   /** Returns a view cells manager of the given name.
@@ -178 +163 @@
           );
 
-  Intersectable *
-  CastSimpleRay(
-                                const Vector3 &viewPoint,
-                                const Vector3 &direction,
-                                const AxisAlignedBox3 &box,
-                                Vector3 &point,
-                                Vector3 &normal
-                                );
   
   ////////////////////////////////////////////////
@@ -234 +211 @@
   float mVisibilityFilterWidth;
  
-  int GetRayCastMethod() { return mRayCastMethod; }
-  void SetRayCastMethod(int rayCastMethod) { mRayCastMethod = rayCastMethod; }
+  //int GetRayCastMethod() { return mRayCastMethod; }
+  //void SetRayCastMethod(int rayCastMethod) { mRayCastMethod = rayCastMethod; }
 
   int mPass;
@@ -241 +218 @@
 protected:
 
-        void SetupRay(Ray &ray, const Vector3 &point, const Vector3 &direction);
-
-  int
-  ProcessRay(
-                         const Vector3 &viewPoint,
-                         const Vector3 &direction,
-                         Intersectable *objectA,
-                         Vector3 &pointA,
-                         const Vector3 &normalA,
-                         Intersectable *objectB,
-                         Vector3 &pointB,
-                         const Vector3 &normalB,
-                         const float probability,
-                         VssRayContainer &vssRays,
-                         const AxisAlignedBox3 &box);
-  
-  int CastInternalRay(
-                                          const Vector3 &viewPoint,
-                                          const Vector3 &direction,
-                                          const float probability,
-                                          VssRayContainer &vssRays,
-                                          const AxisAlignedBox3 &box);
-  
-  int CastIntelDoubleRay(
-                                                 const Vector3 &viewPoint,
-                                                 const Vector3 &direction,
-                                                 const float probability,
-                                                 VssRayContainer &vssRays,
-                                                 const AxisAlignedBox3 &box);
-  
-  Intersectable *CastIntelSingleRay(
-                                                                        const Vector3 &viewPoint,
-                                                                        const Vector3 &direction,
-                                                                        Vector3 &tPoint,
-                                                                        const AxisAlignedBox3 &box);
-  
-  /////////////////////////
-
-  int mRayCastMethod;
+        void SetupRay(Ray &ray, const Vector3 &point, const Vector3 &direction) const;
+
+        // matt: previously was a signal
+        void EvalPvsStat();
+
+        /////////////////////////
+
+  RayCaster *mRayCaster;
   /// samples used for construction of the BSP view cells tree.
   int mBspConstructionSamples;
@@ -287 +233 @@
   */
   RenderSimulator *mRenderSimulator;
-
   
   vector<FaceParentInfo> mFaceParents;
-  
+
   GlRendererBuffer *renderer;
-// matt: remove qt dependencies 
-//signals:
-  void EvalPvsStat();
-
-  protected:
-
-  
-  void CastRays16(const int i,
-                                  SimpleRayContainer &rays, 
-                                  VssRayContainer &vssRays,
-                                  const AxisAlignedBox3 &sbox);
+
   
 };
 
-//extern Preprocessor *preprocessor;
 
 }

GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.vcproj

@@ -217 +217 @@
                                 OptimizeForProcessor="3"
                                 OptimizeForWindowsApplication="TRUE"
-                                AdditionalIncludeDirectories="..\src;..\..\..\..\..\..\NonGTP\Devil\include;..\..\..\..\..\..\NonGTP\Zlib\include;..\..\..\..\..\..\NonGTP\Xerces;..\..\..\..\..\..\NonGTP\Boost;..\MultiLevelRayTracing;"$(QTDIR)\include\QtCore""
+                                AdditionalIncludeDirectories="..\src;..\..\..\..\..\..\NonGTP\Devil\include;..\..\..\..\..\..\NonGTP\Zlib\include;..\..\..\..\..\..\NonGTP\Xerces;..\..\..\..\..\..\NonGTP\Boost;..\MultiLevelRayTracing;"$(QTDIR)\include\QtCore";"$(QTDIR)\include\QtGui";"$(QTDIR)\include""
                                 PreprocessorDefinitions="WIN32;NDEBUG;_LIB;GTP_INTERNAL"
                                 ExceptionHandling="TRUE"
@@ -364 +364 @@
                         <File
                                 RelativePath=".\HierarchyManager.h">
+                        </File>
+                        <File
+                                RelativePath=".\IntelRayCaster.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\IntelRayCaster.h">
+                        </File>
+                        <File
+                                RelativePath=".\InternalRayCaster.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\InternalRayCaster.h">
                         </File>
                         <File
@@ -556 +568 @@
                         </File>
                         <File
+                                RelativePath=".\QtPreprocessorThread.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\QtPreprocessorThread.h">
+                        </File>
+                        <File
                                 RelativePath="..\src\Ray.cpp">
                         </File>
                         <File
                                 RelativePath="..\src\Ray.h">
+                        </File>
+                        <File
+                                RelativePath=".\RayCaster.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\RayCaster.h">
                         </File>
                         <File

GTP/trunk/Lib/Vis/Preprocessing/src/QtGlRenderer/QtGlRenderer.vcproj

@@ -103 +103 @@
                                 Name="VCMIDLTool"/>
                         <Tool
-                                Name="VCPostBuildEventTool"/>
+                                Name="VCPostBuildEventTool"
+                                Description="&quot;copy dll to preprocessor dir&quot;"
+                                CommandLine="copy $(OutDir)\*.dll ..\..\bin\"/>
                         <Tool
                                 Name="VCPreBuildEventTool"/>

GTP/trunk/Lib/Vis/Preprocessing/src/QtPreprocessorThread.cpp

@@ +1 @@
+#ifdef GTP_INTERNAL
 #include <QApplication>
-
 #include "QtPreprocessorThread.h"
 #include "Camera.h"
@@ -17 +17 @@
 {
   if (p->mQuitOnFinish)
-        connect(this, SIGNAL(finished()), qApp, SLOT(closeAllWindows(void)));
+  {
+          connect(this, SIGNAL(finished()), qApp, SLOT(closeAllWindows(void)));
+  }
 }
 
@@ -28 +30 @@
 }
 
+#endif

GTP/trunk/Lib/Vis/Preprocessing/src/RssPreprocessor.cpp

@@ -12 +12 @@
 #include "RenderSimulator.h"
 #include "GlRenderer.h"
+#include "SamplingStrategy.h"
+
 
 namespace GtpVisibilityPreprocessor {
@@ -62 +64 @@
 
   switch (sampleType) {
-  case RSS_BASED_DISTRIBUTION:
-  case RSS_SILHOUETTE_BASED_DISTRIBUTION:
+  case SamplingStrategy::RSS_BASED_DISTRIBUTION:
+  case SamplingStrategy::RSS_SILHOUETTE_BASED_DISTRIBUTION:
         if (mRssTree) {
           GenerateImportanceRays(mRssTree, number, rays);
@@ -554 +556 @@
 
         if (mUseImportanceSampling) {
-          GenerateRays(mInitialSamples/3, SPATIAL_BOX_BASED_DISTRIBUTION, rays);
-          GenerateRays(mInitialSamples/3, OBJECT_BASED_DISTRIBUTION, rays);
-          GenerateRays(mInitialSamples/3, DIRECTION_BASED_DISTRIBUTION, rays);
+          GenerateRays(mInitialSamples/3, SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION, rays);
+          GenerateRays(mInitialSamples/3, SamplingStrategy::OBJECT_BASED_DISTRIBUTION, rays);
+          GenerateRays(mInitialSamples/3, SamplingStrategy::DIRECTION_BASED_DISTRIBUTION, rays);
           //    GenerateRays(mInitialSamples/4, OBJECT_DIRECTION_BASED_DISTRIBUTION, rays);
         } else {
-          int rayType = SPATIAL_BOX_BASED_DISTRIBUTION;
+                int rayType = SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION;
           if (mObjectBasedSampling)
-                rayType = OBJECT_BASED_DISTRIBUTION;
+                rayType = SamplingStrategy::OBJECT_BASED_DISTRIBUTION;
           else
                 if (mDirectionalSampling)
-                  rayType = DIRECTION_BASED_DISTRIBUTION;
+                  rayType = SamplingStrategy::DIRECTION_BASED_DISTRIBUTION;
           cout<<"Generating rays..."<<endl;
           GenerateRays(mRssSamplesPerPass, rayType, rays);
@@ -571 +573 @@
         
         cout<<"Casting initial rays..."<<endl<<flush;
-        CastRays(rays, mVssRays);
+        CastRays(rays, mVssRays, true);
 
         ExportObjectRays(mVssRays, 1546);
@@ -690 +692 @@
           t1 = GetTime();
           
-          GenerateRays(int(mRssSamplesPerPass*ratios[0]), RSS_BASED_DISTRIBUTION, rays);
+          GenerateRays(int(mRssSamplesPerPass*ratios[0]), SamplingStrategy::RSS_BASED_DISTRIBUTION, rays);
 
           rays.NormalizePdf((float)rays.size());
           
-          CastRays(rays, tmpVssRays);
+          CastRays(rays, tmpVssRays, true);
           castRays += (int)rays.size();
 #if ADD_RAYS_IN_PLACE 
@@ -711 +713 @@
           if (ratios[1]!=0.0f) {
                 t1 = GetTime();
-                GenerateRays(int(mRssSamplesPerPass*ratios[1]), SPATIAL_BOX_BASED_DISTRIBUTION, rays);
-                CastRays(rays, tmpVssRays);
+                GenerateRays(int(mRssSamplesPerPass*ratios[1]), SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION, rays);
+                CastRays(rays, tmpVssRays, true);
                 castRays += (int)rays.size();
 #if ADD_RAYS_IN_PLACE 
@@ -733 +735 @@
           if (ratios[2]!=0.0f) {
                 t1 = GetTime();
-                GenerateRays(int(mRssSamplesPerPass*ratios[2]), DIRECTION_BASED_DISTRIBUTION, rays);
-                CastRays(rays, tmpVssRays);
+                GenerateRays(int(mRssSamplesPerPass*ratios[2]), SamplingStrategy::DIRECTION_BASED_DISTRIBUTION, rays);
+                CastRays(rays, tmpVssRays, true);
                 castRays += (int)rays.size();
 #if ADD_RAYS_IN_PLACE 
@@ -775 +777 @@
         }
         else {
-          int rayType = SPATIAL_BOX_BASED_DISTRIBUTION;
+                int rayType = SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION;
           if (mObjectBasedSampling)
-                rayType = OBJECT_BASED_DISTRIBUTION;
+                  rayType = SamplingStrategy::OBJECT_BASED_DISTRIBUTION;
           else
                 if (mDirectionalSampling)
-                  rayType = DIRECTION_BASED_DISTRIBUTION;
+                        rayType = SamplingStrategy::DIRECTION_BASED_DISTRIBUTION;
 
           cout<<"Generating rays..."<<endl;
@@ -788 +790 @@
 
           cout<<"Casting rays..."<<endl;
-          CastRays(rays, vssRays);
+          CastRays(rays, vssRays, true);
           cout<<"done."<<endl;
           castRays += (int)rays.size();

GTP/trunk/Lib/Vis/Preprocessing/src/SamplingPreprocessor.cpp

@@ -47 +47 @@
 
   // cast ray to KD tree to find intersection with other objects
+#if 0
   object = CastSimpleRay(origin,
                                                  direction,
@@ -53 +54 @@
                                                  normal
                                                  );
-  
+#endif
+
   if (mDetectEmptyViewSpace && DotProd(normal, direction) >= 0) {
         object = NULL;

GTP/trunk/Lib/Vis/Preprocessing/src/SamplingStrategy.cpp

@@ -8 +8 @@
 
 namespace GtpVisibilityPreprocessor {
+
+
+SamplingStrategy::SamplingStrategy(const Preprocessor &preprocessor): 
+mPreprocessor(preprocessor)
+{
+}
+
+
+SamplingStrategy::~SamplingStrategy() 
+{
+}
+
 
 
@@ -142 +154 @@
 }
 
-/*
+#if 0
 bool ObjectsInteriorDistribution::GenerateSample(SimpleRay &ray) const
 {
@@ -170 +182 @@
 
         return true;
-}*/
-
 }
+#endif
+}

GTP/trunk/Lib/Vis/Preprocessing/src/SamplingStrategy.h

@@ -15 +15 @@
  public:
 
+         /** Sample rays of particular type
+         */
+         enum 
+         {
+                 OBJECT_BASED_DISTRIBUTION,
+                 DIRECTION_BASED_DISTRIBUTION,
+                 DIRECTION_BOX_BASED_DISTRIBUTION,
+                 SPATIAL_BOX_BASED_DISTRIBUTION,
+                 RSS_BASED_DISTRIBUTION,
+                 RSS_SILHOUETTE_BASED_DISTRIBUTION,
+                 VSS_BASED_DISTRIBUTION,
+                 OBJECT_DIRECTION_BASED_DISTRIBUTION,
+                 OBJECTS_INTERIOR_DISTRIBUTION
+         };
+
          /** Default constructor
      */
-         SamplingStrategy(const Preprocessor &preprocessor): mPreprocessor(preprocessor)
-         {}
+         SamplingStrategy(const Preprocessor &preprocessor);
 
-         virtual ~SamplingStrategy() {};
+         virtual ~SamplingStrategy();
 
          /** Each strategy has to implement this function.

GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

@@ -22 +22 @@
 #include "OspTree.h"
 #include "BvHierarchy.h"
+#include "SamplingStrategy.h"
 
 
@@ -110 +111 @@
         if (strcmp(buf, "box") == 0)
         {
-                mSamplingType = Preprocessor::SPATIAL_BOX_BASED_DISTRIBUTION;
+                mSamplingType = SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION;
         }
         else if (strcmp(buf, "directional") == 0)
         {
-                mSamplingType = Preprocessor::DIRECTION_BASED_DISTRIBUTION;
+                mSamplingType = SamplingStrategy::DIRECTION_BASED_DISTRIBUTION;
         }
         else if (strcmp(buf, "object_directional") == 0)
         {
-                mSamplingType = Preprocessor::OBJECT_DIRECTION_BASED_DISTRIBUTION;
+                mSamplingType = SamplingStrategy::OBJECT_DIRECTION_BASED_DISTRIBUTION;
         }
         /*else if (strcmp(buf, "interior") == 0)
@@ -135 +136 @@
         if (strcmp(buf, "box") == 0)
         {
-                mEvaluationSamplingType = Preprocessor::SPATIAL_BOX_BASED_DISTRIBUTION;
+                mEvaluationSamplingType = SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION;
         }
         else if (strcmp(buf, "directional") == 0)
         {
-                mEvaluationSamplingType = Preprocessor::DIRECTION_BASED_DISTRIBUTION;
+                mEvaluationSamplingType = SamplingStrategy::DIRECTION_BASED_DISTRIBUTION;
         }
         else if (strcmp(buf, "object_directional") == 0)
         {
-                mEvaluationSamplingType = Preprocessor::OBJECT_DIRECTION_BASED_DISTRIBUTION;
+                mEvaluationSamplingType = SamplingStrategy::OBJECT_DIRECTION_BASED_DISTRIBUTION;
         }
         /*else if (strcmp(buf, "interior") == 0)
         {
-                mEvaluationSamplingType = Preprocessor::OBJECTS_INTERIOR_DISTRIBUTION;
+                mEvaluationSamplingType = SamplingStrategy::OBJECTS_INTERIOR_DISTRIBUTION;
         }*/
         else
@@ -271 +272 @@
 
         // shoot simple ray and add it to importance samples
-        mPreprocessor->CastRays(simpleRays, passSamples);
+        mPreprocessor->CastRays(simpleRays, passSamples, true);
         Debug << "cast " <<  samplesPerPass << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
 
@@ -394 +395 @@
         const int n = mConstructionSamples; //+initialSamples;
         // should we use directional samples?
-        bool dirSamples = (mSamplingType == Preprocessor::DIRECTION_BASED_DISTRIBUTION);
+        bool dirSamples = (mSamplingType == SamplingStrategy::DIRECTION_BASED_DISTRIBUTION);
 
         while (numSamples < n)
@@ -489 +490 @@
                 VssRayContainer visualizationSamples;
 
+                ////////
                 //-- visualization rays, e.g., to show some samples in the scene
                 CastPassSamples(mVisualizationSamples,
-                                            Preprocessor::DIRECTION_BASED_DISTRIBUTION, 
+                                            SamplingStrategy::DIRECTION_BASED_DISTRIBUTION, 
                                                 visualizationSamples);
 
@@ -841 +843 @@
 
         // should directional sampling be used?
-        bool dirSamples = (mEvaluationSamplingType == Preprocessor::DIRECTION_BASED_DISTRIBUTION);
+        bool dirSamples = (mEvaluationSamplingType == SamplingStrategy::DIRECTION_BASED_DISTRIBUTION);
 
         cout << "reseting pvs ... ";