Changeset 1221 for GTP/trunk/Lib/Vis/Preprocessing/src/VssPreprocessor.cpp

Timestamp:

08/18/06 19:28:12 (18 years ago)

Author:

mattausch

Message:

added intel ray tracing

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/VssPreprocessor.cpp (modified) (9 diffs)

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

@@ -13 +13 @@
 #include "Beam.h"
 #include "GlRenderer.h"
-#include "ViewCellBsp.h"
+#include "ArchModeler2MLRT.hxx"
+#include "Intersectable.h"
+
 
 namespace GtpVisibilityPreprocessor {
@@ -76 +78 @@
                                                   )
 {
-  for (int i=0; i < rays.size(); i++)
-        CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);
+        AxisAlignedBox3 &box =  mViewSpaceBox ? *mViewSpaceBox : mKdTree->GetBox();
+        
+#if 1
+        for (int i=0; i < rays.size(); i++)
+        {
+                CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays, box);
+        }
+#else
+        for (int i = 0; i < rays.size(); i += 16)
+        {
+                CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays, box);
+        }
+
+#endif
+}
+
+
+void VssPreprocessor::CastRays16(SimpleRayContainer &rays, 
+                                                                 VssRayContainer &vssRays,
+                                                                 const AxisAlignedBox3 &sbox)
+{
+/*
+        mlrtaStoreRayAS16(const float* pforg, const float* pfdir, int j);
+
+
+        // input parameters
+        const RTVec3f& org = *reinterpret_cast<const RTVec3f*> (pforg);
+        const RTVec3f& rd  = *reinterpret_cast<const RTVec3f*> (pfdir);
+
+        int ri = j/4;
+        int ci = j%4;
+        *((float*)&ibp4.ray4X[ri].m_origin.t[0] + ci) = org[0];
+        *((float*)&ibp4.ray4X[ri].m_origin.t[1] + ci) = org[1];
+        *((float*)&ibp4.ray4X[ri].m_origin.t[2] + ci) = org[2];
+
+        *((float*)&ibp4.ray4X[ri].m_direction.t[0] + ci) = rd[0];
+        *((float*)&ibp4.ray4X[ri].m_direction.t[1] + ci) = rd[1];
+        *((float*)&ibp4.ray4X[ri].m_direction.t[2] + ci) = rd[2];
+
+        mlrtaTraverseGroupAS16(const float* bbmin, const float* bbmax, int* hit_triangles, float* dist);*/
+}
+
+
+int VssPreprocessor::CastIntelDoubleRay(
+                                                                                const Vector3 &viewPoint,
+                                                                                const Vector3 &direction,
+                                                                                VssRayContainer &vssRays,
+                                                                                const AxisAlignedBox3 &box)
+{
+        VssRay *vssRay  = NULL;
+        int hits = 0;
+
+        Vector3 pointA, pointB;
+        
+        Intersectable *objectA = 
+                CastIntelSingleRay(viewPoint, direction, pointA, box);
+        
+        // cast ray into other direction
+        Intersectable *objectB = 
+                CastIntelSingleRay(viewPoint, -direction, pointB, box);
+
+        const bool validSample = (objectA != objectB);
+        
+        if (validSample) 
+        {       
+                if (objectA) 
+                {
+                        vssRay = new VssRay(pointB,
+                                                                pointA,
+                                                                objectB,
+                                                                objectA,
+                                                                mPass);
+                        vssRays.push_back(vssRay);
+                        hits ++;
+                }
+
+                if (objectB) 
+                {
+                        vssRay = new VssRay(pointA,
+                                                                pointB,
+                                                                objectA,
+                                                                objectB,
+                                                                mPass);
+                        vssRays.push_back(vssRay);
+                        hits ++;
+                }
+                //Debug << "intel ray: " << *vssRay << endl;
+        }
+//cout << "a";
+        return hits;
+}
+
+
+Intersectable *VssPreprocessor::CastIntelSingleRay(const Vector3 &viewPoint,
+                                                                                                   const Vector3 &direction,
+                                                                                                   Vector3 &tPoint,
+                                                                                                   const AxisAlignedBox3 &box
+                                                                                                   )
+{
+        AxisAlignedBox3 sbox = box;
+        sbox.Enlarge(Vector3(-Limits::Small));
+
+        if (!sbox.IsInside(viewPoint))
+                return 0;
+        
+        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 = 0;
+        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
+        {
+                tPoint[0] = pforg[0] + pfdir[0] * dist;
+                tPoint[1] = pforg[1] + pfdir[1] * dist;
+                tPoint[2] = pforg[2] + pfdir[2] * dist;
+
+                return mFaceParents[hittriangle];
+        }
 }
 
 
 int
-VssPreprocessor::CastRay(
-                                                 Vector3 &viewPoint,
-                                                 Vector3 &direction,
-                                                 VssRayContainer &vssRays
-                                                 )
-{
-
+VssPreprocessor::CastInternalRay(
+                                                                 const Vector3 &viewPoint,
+                                                                 const Vector3 &direction,
+                                                                 VssRayContainer &vssRays,
+                                                                 const AxisAlignedBox3 &box 
+                                                                 )
+{
     int hits = 0;
         static Ray ray;
-        
-        AxisAlignedBox3 box =  mViewSpaceBox ? *mViewSpaceBox : mKdTree->GetBox();
+
         AxisAlignedBox3 sbox = box;
-    
         sbox.Enlarge(Vector3(-Limits::Small));
-        
+
         if (!sbox.IsInside(viewPoint))
                 return 0;
@@ -109 +243 @@
 
         //float bsize = Magnitude(box.Size());
-
         if (!mDetectEmptyViewSpace)
                 ray.mFlags &= ~Ray::CULL_BACKFACES;
@@ -132 +265 @@
 
         // matt: point A could be undefined?
+
+        // cast ray into opposite direction
         if (1 && mDetectEmptyViewSpace) {
                 SetupRay(ray, pointA, -direction);
@@ -215 +350 @@
                         hits ++;
                 }
-        }
-        
+                //Debug << "internal ray: " << *vssRay << endl << endl;
+        }
+//cout << "b";
         return hits;
+}
+
+
+int
+VssPreprocessor::CastRay(
+                                                 const Vector3 &viewPoint,
+                                                 const Vector3 &direction,
+                                                 VssRayContainer &vssRays,
+                                                 const AxisAlignedBox3 &box
+                                                 )
+{
+        switch (mRayCastMethod)
+        {
+        case INTEL_RAYCASTER:
+                return CastIntelDoubleRay(viewPoint, direction, vssRays, box);
+        case INTERNAL_RAYCASTER:
+        default:
+                return CastInternalRay(viewPoint, direction, vssRays, box);
+        }
 }
 
@@ -565 +720 @@
         box.SetMax(1, box.Min(1));
 
-  cout << "use view space box=" << mUseViewSpaceBox<<endl;
+  cout << "use view space box=" << mUseViewSpaceBox << endl;
 
   
   if (mUseViewSpaceBox)
   {
+        //mViewSpaceBox = ConstructViewSpaceBox();
+
           if (!mEnlargeViewSpace)
           {
@@ -671 +828 @@
                         Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
 
-                        sampleContributions = CastRay(viewpoint, direction, mVssRays);
+                        sampleContributions = CastRay(viewpoint, direction, mVssRays, vbox);
 
                         if (sampleContributions) {
@@ -802 +959 @@
 
         for (int i=0; i < rays.size(); i++)
-          CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);
+          CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays, vbox);
 
         vssTree->AddRays(vssRays);
@@ -842 +999 @@
   }
 
-  if (0)
-          Debug << vssTree->stat << endl;
+  if (0)  Debug << vssTree->stat << endl;
 
   if (0)
   {
         VssRayContainer viewCellRays;
-  
-        // compute rays used for view cells construction
+        // compute rays used for view cells construction
         const int numRays = mViewCellsManager->GetVisualizationSamples();
-
         vssTree->CollectRays(viewCellRays, numRays);
   }